diff options
Diffstat (limited to 'comm/mail/test/browser/shared-modules')
29 files changed, 11828 insertions, 0 deletions
diff --git a/comm/mail/test/browser/shared-modules/.eslintrc.js b/comm/mail/test/browser/shared-modules/.eslintrc.js new file mode 100644 index 0000000000..e57058ecb1 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/.eslintrc.js @@ -0,0 +1,7 @@ +"use strict"; + +module.exports = { + env: { + webextensions: true, + }, +}; diff --git a/comm/mail/test/browser/shared-modules/AccountManagerHelpers.jsm b/comm/mail/test/browser/shared-modules/AccountManagerHelpers.jsm new file mode 100644 index 0000000000..5cd8d6d6bc --- /dev/null +++ b/comm/mail/test/browser/shared-modules/AccountManagerHelpers.jsm @@ -0,0 +1,204 @@ +/* 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 EXPORTED_SYMBOLS = [ + "openAccountProvisioner", + "openAccountSetup", + "openAccountSettings", + "open_advanced_settings", + "click_account_tree_row", + "get_account_tree_row", + "remove_account", + "wait_for_account_tree_load", +]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +var fdh = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var wh = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +var { content_tab_e, open_content_tab_with_url, wait_for_content_tab_load } = + ChromeUtils.import("resource://testing-common/mozmill/ContentTabHelpers.jsm"); + +var mc = fdh.mc; + +/** + * Waits until the Account Manager tree fully loads after first open. + */ +function wait_for_account_tree_load(tab) { + utils.waitFor( + () => tab.browser.contentWindow.currentAccount != null, + "Timeout waiting for currentAccount to become non-null" + ); +} + +async function openAccountSettings() { + return new Promise(resolve => { + let tab = open_content_tab_with_url("about:accountsettings"); + wait_for_account_tree_load(tab); + resolve(tab); + }); +} + +/** + * Opens the Account Manager. + * + * @callback tabCallback + * + * @param {tabCallback} callback - The callback for the account manager tab that is opened. + */ +async function open_advanced_settings(callback) { + let tab = open_content_tab_with_url("about:accountsettings"); + wait_for_account_tree_load(tab); + await callback(tab); + mc.window.document.getElementById("tabmail").closeTab(tab); +} + +async function openAccountSetup() { + return new Promise(resolve => { + let tab = open_content_tab_with_url("about:accountsetup"); + wait_for_content_tab_load(tab, "about:accountsetup", 10000); + resolve(tab); + }); +} + +async function openAccountProvisioner() { + return new Promise(resolve => { + let tab = open_content_tab_with_url("about:accountprovisioner"); + wait_for_content_tab_load(tab, "about:accountprovisioner", 10000); + resolve(tab); + }); +} + +/** + * Click a row in the account settings tree. + * + * @param {object} tab - The account manager tab controller that opened. + * @param {number} rowIndex - The row to click. + */ +function click_account_tree_row(tab, rowIndex) { + utils.waitFor( + () => tab.browser.contentWindow.currentAccount != null, + "Timeout waiting for currentAccount to become non-null" + ); + + let tree = content_tab_e(tab, "accounttree"); + tree.selectedIndex = rowIndex; + + utils.waitFor( + () => tab.browser.contentWindow.pendingAccount == null, + "Timeout waiting for pendingAccount to become null" + ); + + // Ensure the page is fully loaded (e.g. onInit functions). + wh.wait_for_frame_load( + content_tab_e(tab, "contentFrame"), + tab.browser.contentWindow.pageURL( + tree.rows[rowIndex].getAttribute("PageTag") + ) + ); +} + +/** + * Returns the index of the row in account tree corresponding to the wanted + * account and its settings pane. + * + * @param {number} accountKey - The key of the account to return. + * If 'null', the SMTP pane is returned. + * @param {number} paneId - The ID of the account settings pane to select. + * + * + * @returns {number} The row index of the account and pane. If it was not found return -1. + * Do not throw as callers may intentionally just check if a row exists. + * Just dump into the log so that a subsequent throw in + * click_account_tree_row has a useful context. + */ +function get_account_tree_row(accountKey, paneId, tab) { + let accountTree = content_tab_e(tab, "accounttree"); + let row; + if (accountKey && paneId) { + row = accountTree.querySelector(`#${accountKey} [PageTag="${paneId}"]`); + } else if (accountKey) { + row = accountTree.querySelector(`#${accountKey}`); + } + return accountTree.rows.indexOf(row); +} + +/** + * Remove an account via the account manager UI. + * + * @param {object} account - The account to remove. + * @param {object} tab - The account manager tab that opened. + * @param {boolean} removeAccount - Remove the account itself. + * @param {boolean} removeData - Remove the message data of the account. + */ +function remove_account( + account, + tab, + removeAccount = true, + removeData = false +) { + let accountRow = get_account_tree_row(account.key, null, tab); + click_account_tree_row(tab, accountRow); + + account = null; + // Use the Remove item in the Account actions menu. + let actionsButton = content_tab_e(tab, "accountActionsButton"); + EventUtils.synthesizeMouseAtCenter( + actionsButton, + { clickCount: 1 }, + actionsButton.ownerGlobal + ); + let actionsDd = content_tab_e(tab, "accountActionsDropdown"); + utils.waitFor( + () => actionsDd.state == "open" || actionsDd.state == "showing" + ); + let remove = content_tab_e(tab, "accountActionsDropdownRemove"); + EventUtils.synthesizeMouseAtCenter( + remove, + { clickCount: 1 }, + remove.ownerGlobal + ); + utils.waitFor(() => actionsDd.state == "closed"); + + let cdc = wh.wait_for_frame_load( + tab.browser.contentWindow.gSubDialog._topDialog._frame, + "chrome://messenger/content/removeAccount.xhtml" + ); + + // Account removal confirmation dialog. Select what to remove. + if (removeAccount) { + EventUtils.synthesizeMouseAtCenter( + cdc.window.document.getElementById("removeAccount"), + {}, + cdc.window.document.getElementById("removeAccount").ownerGlobal + ); + } + if (removeData) { + EventUtils.synthesizeMouseAtCenter( + cdc.window.document.getElementById("removeData"), + {}, + cdc.window.document.getElementById("removeData").ownerGlobal + ); + } + + cdc.window.document.documentElement.querySelector("dialog").acceptDialog(); + utils.waitFor( + () => + !cdc.window.document.querySelector("dialog").getButton("accept").disabled, + "Timeout waiting for finish of account removal", + 5000, + 100 + ); + cdc.window.document.documentElement.querySelector("dialog").acceptDialog(); +} diff --git a/comm/mail/test/browser/shared-modules/AddressBookHelpers.jsm b/comm/mail/test/browser/shared-modules/AddressBookHelpers.jsm new file mode 100644 index 0000000000..cce1fd81a1 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/AddressBookHelpers.jsm @@ -0,0 +1,182 @@ +/* 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 EXPORTED_SYMBOLS = [ + "create_address_book", + "create_contact", + "create_ldap_address_book", + "create_mailing_list", + "delete_address_book", + "ensure_card_exists", + "ensure_no_card_exists", + "get_cards_in_all_address_books_for_email", + "get_mailing_list_from_address_book", + "load_contacts_into_address_book", +]; + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +var ABJS_PREFIX = "jsaddrbook://"; +var ABLDAP_PREFIX = "moz-abldapdirectory://"; + +var collectedAddresses; + +// Ensure all the directories are initialised. +MailServices.ab.directories; +collectedAddresses = MailServices.ab.getDirectory( + "jsaddrbook://history.sqlite" +); + +/** + * Make sure that there is a card for this email address + * + * @param emailAddress the address that should have a card + * @param displayName the display name the card should have + * @param preferDisplayName |true| if the card display name should override the + * header display name + */ +function ensure_card_exists(emailAddress, displayName, preferDisplayName) { + ensure_no_card_exists(emailAddress); + let card = create_contact(emailAddress, displayName, preferDisplayName); + collectedAddresses.addCard(card); +} + +/** + * Make sure that there is no card for this email address + * + * @param emailAddress the address that should have no cards + */ +function ensure_no_card_exists(emailAddress) { + for (let ab of MailServices.ab.directories) { + try { + var card = ab.cardForEmailAddress(emailAddress); + if (card) { + ab.deleteCards([card]); + } + } catch (ex) {} + } +} + +/** + * Return all address book cards for a particular email address + * + * @param aEmailAddress the address to search for + */ +function get_cards_in_all_address_books_for_email(aEmailAddress) { + var result = []; + + for (let ab of MailServices.ab.directories) { + var card = ab.cardForEmailAddress(aEmailAddress); + if (card) { + result.push(card); + } + } + + return result; +} + +/** + * Creates and returns a SQLite-backed address book. + * + * @param aName the name for the address book + * @returns the nsIAbDirectory address book + */ +function create_address_book(aName) { + let abPrefString = MailServices.ab.newAddressBook(aName, "", 101); + let abURI = Services.prefs.getCharPref(abPrefString + ".filename"); + return MailServices.ab.getDirectory(ABJS_PREFIX + abURI); +} + +/** + * Creates and returns an LDAP-backed address book. + * This function will automatically fill in a dummy + * LDAP URI if no URI is supplied. + * + * @param aName the name for the address book + * @param aURI an optional URI for the address book + * @returns the nsIAbDirectory address book + */ +function create_ldap_address_book(aName, aURI) { + if (!aURI) { + aURI = "ldap://dummyldap/??sub?(objectclass=*)"; + } + let abPrefString = MailServices.ab.newAddressBook(aName, aURI, 0); + return MailServices.ab.getDirectory(ABLDAP_PREFIX + abPrefString); +} + +/** + * Creates and returns an address book contact + * + * @param aEmailAddress the e-mail address for this contact + * @param aDisplayName the display name for the contact + * @param aPreferDisplayName set to true if the card display name should + * override the header display name + */ +function create_contact(aEmailAddress, aDisplayName, aPreferDisplayName) { + let card = Cc["@mozilla.org/addressbook/cardproperty;1"].createInstance( + Ci.nsIAbCard + ); + card.primaryEmail = aEmailAddress; + card.displayName = aDisplayName; + card.setProperty("PreferDisplayName", !!aPreferDisplayName); + return card; +} + +/* Creates and returns a mailing list + * @param aMailingListName the display name for the new mailing list + */ +function create_mailing_list(aMailingListName) { + var mailList = Cc[ + "@mozilla.org/addressbook/directoryproperty;1" + ].createInstance(Ci.nsIAbDirectory); + mailList.isMailList = true; + mailList.dirName = aMailingListName; + return mailList; +} + +/* Finds and returns a mailing list with a given dirName within a + * given address book. + * @param aAddressBook the address book to search + * @param aDirName the dirName of the mailing list + */ +function get_mailing_list_from_address_book(aAddressBook, aDirName) { + for (let list of aAddressBook.childNodes) { + if (list.dirName == aDirName) { + return list; + } + } + throw Error("Could not find a mailing list with dirName " + aDirName); +} + +/* Given some address book, adds a collection of contacts to that + * address book. + * @param aAddressBook an address book to add the contacts to + * @param aContacts a collection of nsIAbCards, or contacts, + * where each contact has members "email" + * and "displayName" + * + * Example: + * [{email: 'test@example.com', displayName: 'Sammy Jenkis'}] + */ +function load_contacts_into_address_book(aAddressBook, aContacts) { + for (let i = 0; i < aContacts.length; i++) { + let contact = aContacts[i]; + if (!(contact instanceof Ci.nsIAbCard)) { + contact = create_contact(contact.email, contact.displayName, true); + } + + aContacts[i] = aAddressBook.addCard(contact); + } +} + +/** + * Deletes an address book. + */ +function delete_address_book(aAddrBook) { + MailServices.ab.deleteAddressBook(aAddrBook.URI); +} diff --git a/comm/mail/test/browser/shared-modules/AttachmentHelpers.jsm b/comm/mail/test/browser/shared-modules/AttachmentHelpers.jsm new file mode 100644 index 0000000000..971b25fa77 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/AttachmentHelpers.jsm @@ -0,0 +1,240 @@ +/* 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 EXPORTED_SYMBOLS = [ + "create_body_part", + "create_deleted_attachment", + "create_detached_attachment", + "create_enclosure_attachment", + "gMockFilePicker", + "gMockFilePickReg", + "select_attachments", +]; + +var { MockObjectReplacer } = ChromeUtils.import( + "resource://testing-common/mozmill/MockObjectHelpers.jsm" +); + +var gMockFilePickReg = new MockObjectReplacer( + "@mozilla.org/filepicker;1", + MockFilePickerConstructor +); + +function MockFilePickerConstructor() { + return gMockFilePicker; +} + +var gMockFilePicker = { + QueryInterface: ChromeUtils.generateQI(["nsIFilePicker"]), + defaultExtension: "", + filterIndex: null, + displayDirectory: null, + returnFiles: [], + addToRecentDocs: false, + + get defaultString() { + throw Components.Exception("", Cr.NS_ERROR_FAILURE); + }, + + get fileURL() { + return null; + }, + + get file() { + if (this.returnFiles.length >= 1) { + return this.returnFiles[0]; + } + return null; + }, + + get files() { + let self = this; + return { + index: 0, + QueryInterface: ChromeUtils.generateQI(["nsISimpleEnumerator"]), + hasMoreElements() { + return this.index < self.returnFiles.length; + }, + getNext() { + return self.returnFiles[this.index++]; + }, + [Symbol.iterator]() { + return self.returnFiles.values(); + }, + }; + }, + + init(aParent, aTitle, aMode) {}, + + appendFilters(aFilterMask) {}, + + appendFilter(aTitle, aFilter) {}, + + open(aFilePickerShownCallback) { + aFilePickerShownCallback.done(Ci.nsIFilePicker.returnOK); + }, + + set defaultString(aVal) {}, +}; + +/** + * Create a body part with attachments for the message generator + * + * @param body the text of the main body of the message + * @param attachments an array of attachment objects (as strings) + * @param boundary an optional string defining the boundary of the parts + * @returns an object suitable for passing as the |bodyPart| for create_message + */ +function create_body_part(body, attachments, boundary) { + if (!boundary) { + boundary = "------------CHOPCHOP"; + } + + return { + contentTypeHeaderValue: 'multipart/mixed;\r\n boundary="' + boundary + '"', + toMessageString() { + let str = + "This is a multi-part message in MIME format.\r\n" + + "--" + + boundary + + "\r\n" + + "Content-Type: text/plain; charset=ISO-8859-1; " + + "format=flowed\r\n" + + "Content-Transfer-Encoding: 7bit\r\n\r\n" + + body + + "\r\n\r\n"; + + for (let i = 0; i < attachments.length; i++) { + str += "--" + boundary + "\r\n" + attachments[i] + "\r\n"; + } + + str += "--" + boundary + "--"; + return str; + }, + }; +} + +function help_create_detached_deleted_attachment(filename, type) { + return ( + "You deleted an attachment from this message. The original MIME " + + "headers for the attachment were:\r\n" + + "Content-Type: " + + type + + ";\r\n" + + ' name="' + + filename + + '"\r\n' + + "Content-Transfer-Encoding: 7bit\r\n" + + "Content-Disposition: attachment;\r\n" + + ' filename="' + + filename + + '"\r\n\r\n' + ); +} + +/** + * Create the raw data for a detached attachment + * + * @param file an nsIFile for the external file for the attachment + * @param type the content type + * @returns a string representing the attachment + */ +function create_detached_attachment(file, type) { + let fileHandler = Services.io + .getProtocolHandler("file") + .QueryInterface(Ci.nsIFileProtocolHandler); + let url = fileHandler.getURLSpecFromActualFile(file); + let filename = file.leafName; + + let str = + 'Content-Type: text/plain;\r\n name="' + + filename + + '"\r\n' + + 'Content-Disposition: attachment; filename="' + + filename + + '"\r\n' + + "X-Mozilla-External-Attachment-URL: " + + url + + "\r\n" + + 'X-Mozilla-Altered: AttachmentDetached; date="' + + 'Wed Oct 06 17:28:24 2010"\r\n\r\n'; + + str += help_create_detached_deleted_attachment(filename, type); + return str; +} + +/** + * Create the raw data for a deleted attachment + * + * @param filename the "original" filename + * @param type the content type + * @returns a string representing the attachment + */ +function create_deleted_attachment(filename, type) { + let str = + 'Content-Type: text/x-moz-deleted; name="Deleted: ' + + filename + + '"\r\n' + + "Content-Transfer-Encoding: 8bit\r\n" + + 'Content-Disposition: inline; filename="Deleted: ' + + filename + + '"\r\n' + + 'X-Mozilla-Altered: AttachmentDeleted; date="' + + 'Wed Oct 06 17:28:24 2010"\r\n\r\n'; + str += help_create_detached_deleted_attachment(filename, type); + return str; +} + +/** + * Create the raw data for a feed enclosure attachment. + * + * @param filename the filename + * @param type the content type + * @param url the remote link url + * @param size the optional size (use > 1 for real size) + * @returns a string representing the attachment + */ +function create_enclosure_attachment(filename, type, url, size) { + return ( + "Content-Type: " + + type + + '; name="' + + filename + + (size ? '"; size=' + size : '"') + + "\r\n" + + "X-Mozilla-External-Attachment-URL: " + + url + + "\r\n" + + 'Content-Disposition: attachment; filename="' + + filename + + '"\r\n\r\n' + + "This MIME attachment is stored separately from the message." + ); +} + +/** + * A helper function that selects either one, or a continuous range + * of items in the attachment list. + * + * @param aController a composer window controller + * @param aIndexStart the index of the first item to select + * @param aIndexEnd (optional) the index of the last item to select + */ +function select_attachments(aController, aIndexStart, aIndexEnd) { + let bucket = aController.window.document.getElementById("attachmentBucket"); + bucket.clearSelection(); + + if (aIndexEnd !== undefined) { + let startItem = bucket.getItemAtIndex(aIndexStart); + let endItem = bucket.getItemAtIndex(aIndexEnd); + bucket.selectItemRange(startItem, endItem); + } else { + bucket.selectedIndex = aIndexStart; + } + + bucket.focus(); + return [...bucket.selectedItems]; +} diff --git a/comm/mail/test/browser/shared-modules/CloudfileHelpers.jsm b/comm/mail/test/browser/shared-modules/CloudfileHelpers.jsm new file mode 100644 index 0000000000..a8c937e770 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/CloudfileHelpers.jsm @@ -0,0 +1,278 @@ +/* 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 EXPORTED_SYMBOLS = [ + "gMockCloudfileManager", + "MockCloudfileAccount", + "getFile", + "collectFiles", + "CloudFileTestProvider", +]; + +var fdh = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var { cloudFileAccounts } = ChromeUtils.import( + "resource:///modules/cloudFileAccounts.jsm" +); + +var kDefaults = { + type: "default", + displayName: "default", + iconURL: "chrome://messenger/content/extension.svg", + accountKey: null, + managementURL: "", + reuseUploads: true, + authErr: cloudFileAccounts.constants.authErr, + offlineErr: cloudFileAccounts.constants.offlineErr, + uploadErr: cloudFileAccounts.constants.uploadErr, + uploadWouldExceedQuota: cloudFileAccounts.constants.uploadWouldExceedQuota, + uploadExceedsFileLimit: cloudFileAccounts.constants.uploadExceedsFileLimit, + uploadCancelled: cloudFileAccounts.constants.uploadCancelled, +}; + +function getFile(aFilename, aRoot) { + var file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.initWithPath(aRoot); + file.append(aFilename); + Assert.ok(file.exists, "File " + aFilename + " does not exist."); + return file; +} + +/** + * Helper function for getting the nsIFile's for some files located + * in a subdirectory of the test directory. + * + * @param aFiles an array of filename strings for files underneath the test + * file directory. + * @param aFileRoot the file who's parent directory we should start looking + * for aFiles in. + * + * Example: + * let files = collectFiles(['./data/testFile1', './data/testFile2'], + * __file__); + */ +function collectFiles(aFiles, aFileRoot) { + return aFiles.map(filename => getFile(filename, aFileRoot)); +} + +function MockCloudfileAccount() { + for (let someDefault in kDefaults) { + this[someDefault] = kDefaults[someDefault]; + } +} + +MockCloudfileAccount.prototype = { + _nextId: 1, + _uploads: new Map(), + + init(aAccountKey, aOverrides = {}) { + for (let override in aOverrides) { + this[override] = aOverrides[override]; + } + this.accountKey = aAccountKey; + + Services.prefs.setCharPref( + "mail.cloud_files.accounts." + aAccountKey + ".displayName", + aAccountKey + ); + Services.prefs.setCharPref( + "mail.cloud_files.accounts." + aAccountKey + ".type", + aAccountKey + ); + cloudFileAccounts._accounts.set(aAccountKey, this); + }, + + renameFile(window, uploadId, newName) { + if (this.renameError) { + throw Components.Exception( + this.renameError.message, + this.renameError.result + ); + } + + let upload = this._uploads.get(uploadId); + upload.url = `https://www.example.com/${this.accountKey}/${newName}`; + upload.name = newName; + return upload; + }, + + isReusedUpload() { + return false; + }, + + uploadFile(window, aFile) { + if (this.uploadError) { + return Promise.reject( + Components.Exception(this.uploadError.message, this.uploadError.result) + ); + } + + return new Promise((resolve, reject) => { + let upload = { + // Values used in the WebExtension CloudFile type. + id: this._nextId++, + url: this.urlForFile(aFile), + name: aFile.leafName, + // Properties of the local file. + path: aFile.path, + size: aFile.exists() ? aFile.fileSize : 0, + // Use aOverrides to set these. + serviceIcon: this.serviceIcon || this.iconURL, + serviceName: this.serviceName || this.displayName, + serviceUrl: this.serviceUrl || "", + downloadPasswordProtected: this.downloadPasswordProtected || false, + downloadLimit: this.downloadLimit || 0, + downloadExpiryDate: this.downloadExpiryDate || null, + // Usage tracking. + immutable: false, + }; + this._uploads.set(upload.id, upload); + gMockCloudfileManager.inProgressUploads.add({ + resolve, + reject, + resolveData: upload, + }); + }); + }, + + urlForFile(aFile) { + return `https://www.example.com/${this.accountKey}/${aFile.leafName}`; + }, + + cancelFileUpload(window, aUploadId) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + + deleteFile(window, aUploadId) { + return new Promise(resolve => fdh.mc.window.setTimeout(resolve)); + }, +}; + +var gMockCloudfileManager = { + _mock_map: {}, + + register(aID, aOverrides) { + if (!aID) { + aID = "default"; + } + + if (!aOverrides) { + aOverrides = {}; + } + + cloudFileAccounts.registerProvider(aID, { + type: aID, + displayName: aID, + iconURL: "chrome://messenger/content/extension.svg", + initAccount(accountKey, aAccountOverrides = {}) { + let account = new MockCloudfileAccount(); + for (let override in aOverrides) { + if (!aAccountOverrides.hasOwnProperty(override)) { + aAccountOverrides[override] = aOverrides[override]; + } + } + account.init(accountKey, aAccountOverrides); + return account; + }, + }); + }, + + unregister(aID) { + if (!aID) { + aID = "default"; + } + + cloudFileAccounts.unregisterProvider(aID); + }, + + inProgressUploads: new Set(), + resolveUploads() { + let uploads = []; + for (let upload of this.inProgressUploads.values()) { + uploads.push(upload.resolveData); + upload.resolve(upload.resolveData); + } + this.inProgressUploads.clear(); + return uploads; + }, + rejectUploads() { + for (let upload of this.inProgressUploads.values()) { + upload.reject( + Components.Exception( + "Upload error.", + cloudFileAccounts.constants.uploadErr + ) + ); + } + this.inProgressUploads.clear(); + }, +}; + +class CloudFileTestProvider { + constructor(name = "CloudFileTestProvider") { + this.extension = null; + this.name = name; + } + + get providerType() { + return `ext-${this.extension.id}`; + } + + /** + * Register an extension based cloudFile provider. + * + * @param testScope - scope of the test, mostly "this" + * @param [background] - optional background script, overriding the default + */ + async register(testScope, background) { + if (!testScope) { + throw new Error("Missing testScope for CloudFileTestProvider.init()."); + } + + async function default_background() { + function fileListener(account, { id, name, data }, tab, relatedFileInfo) { + return { url: "https://example.com/" + name }; + } + browser.cloudFile.onFileUpload.addListener(fileListener); + } + + this.extension = testScope.ExtensionTestUtils.loadExtension({ + files: { + "background.js": background || default_background, + }, + manifest: { + cloud_file: { + name: this.name, + management_url: "/content/management.html", + }, + applications: { gecko: { id: `${this.name}@mochi.test` } }, + background: { scripts: ["background.js"] }, + }, + }); + + await this.extension.startup(); + } + + async unregister() { + cloudFileAccounts.unregisterProvider(this.providerType); + await this.extension.unload(); + } + + async createAccount(displayName) { + let account = await cloudFileAccounts.createAccount(this.providerType); + cloudFileAccounts.setDisplayName(account, displayName); + return account; + } + + removeAccount(aKeyOrAccount) { + return cloudFileAccounts.removeAccount(aKeyOrAccount); + } +} diff --git a/comm/mail/test/browser/shared-modules/ComposeHelpers.jsm b/comm/mail/test/browser/shared-modules/ComposeHelpers.jsm new file mode 100644 index 0000000000..0d32769760 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/ComposeHelpers.jsm @@ -0,0 +1,2430 @@ +/* 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 EXPORTED_SYMBOLS = [ + "add_attachments", + "add_cloud_attachments", + "rename_selected_cloud_attachment", + "convert_selected_to_cloud_attachment", + "assert_previous_text", + "async_wait_for_compose_window", + "clear_recipients", + "close_compose_window", + "create_msg_attachment", + "delete_attachment", + "get_compose_body", + "get_first_pill", + "get_msg_source", + "open_compose_from_draft", + "open_compose_new_mail", + "open_compose_with_edit_as_new", + "open_compose_with_forward", + "open_compose_with_forward_as_attachments", + "open_compose_with_reply", + "open_compose_with_reply_to_all", + "open_compose_with_reply_to_list", + "save_compose_message", + "setup_msg_contents", + "type_in_composer", + "wait_for_compose_window", + "FormatHelper", +]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +var { get_about_message, mc } = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var { gMockCloudfileManager } = ChromeUtils.import( + "resource://testing-common/mozmill/CloudfileHelpers.jsm" +); +var windowHelper = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); +var { get_notification } = ChromeUtils.import( + "resource://testing-common/mozmill/NotificationBoxHelpers.jsm" +); +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); +var { TestUtils } = ChromeUtils.importESModule( + "resource://testing-common/TestUtils.sys.mjs" +); + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +var kTextNodeType = 3; + +/** + * Opens the compose window by starting a new message + * + * @param aController the controller for the mail:3pane from which to spawn + * the compose window. If left blank, defaults to mc. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + * + */ +function open_compose_new_mail(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + EventUtils.synthesizeKey( + "n", + { shiftKey: false, accelKey: true }, + aController.window + ); + + return wait_for_compose_window(); +} + +/** + * Opens the compose window by replying to a selected message and waits for it + * to load. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_with_reply(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + EventUtils.synthesizeKey( + "r", + { shiftKey: false, accelKey: true }, + aController.window + ); + + return wait_for_compose_window(); +} + +/** + * Opens the compose window by replying to all for a selected message and waits + * for it to load. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_with_reply_to_all(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + EventUtils.synthesizeKey( + "R", + { shiftKey: true, accelKey: true }, + aController.window + ); + + return wait_for_compose_window(); +} + +/** + * Opens the compose window by replying to list for a selected message and waits for it + * to load. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_with_reply_to_list(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + EventUtils.synthesizeKey( + "l", + { shiftKey: true, accelKey: true }, + aController.window + ); + + return wait_for_compose_window(); +} + +/** + * Opens the compose window by forwarding the selected messages as attachments + * and waits for it to load. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_with_forward_as_attachments(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + aController.window.goDoCommand("cmd_forwardAttachment"); + + return wait_for_compose_window(); +} + +/** + * Opens the compose window by editing the selected message as new + * and waits for it to load. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_with_edit_as_new(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + aController.window.goDoCommand("cmd_editAsNew"); + + return wait_for_compose_window(); +} + +/** + * Opens the compose window by forwarding the selected message and waits for it + * to load. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_with_forward(aController) { + if (aController === undefined) { + aController = mc; + } + + windowHelper.plan_for_new_window("msgcompose"); + EventUtils.synthesizeKey( + "l", + { shiftKey: false, accelKey: true }, + aController.window + ); + + return wait_for_compose_window(); +} + +/** + * Open draft editing by clicking the "Edit" on the draft notification bar + * of the selected message. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +function open_compose_from_draft(win = get_about_message()) { + windowHelper.plan_for_new_window("msgcompose"); + let box = get_notification(win, "mail-notification-top", "draftMsgContent"); + EventUtils.synthesizeMouseAtCenter( + box.buttonContainer.firstElementChild, + {}, + win + ); + return wait_for_compose_window(); +} + +/** + * Saves the message being composed and waits for the save to complete. + * + * @param {Window} win - A messengercompose.xhtml window. + */ +async function save_compose_message(win) { + let savePromise = BrowserTestUtils.waitForEvent(win, "aftersave"); + win.document.querySelector("#button-save").click(); + await savePromise; +} + +/** + * Closes the requested compose window. + * + * @param aController the controller whose window is to be closed. + * @param aShouldPrompt (optional) true: check that the prompt to save appears + * false: check there's no prompt to save + */ +function close_compose_window(aController, aShouldPrompt) { + if (aShouldPrompt === undefined) { + // caller doesn't care if we get a prompt + windowHelper.close_window(aController); + return; + } + + windowHelper.plan_for_window_close(aController); + if (aShouldPrompt) { + windowHelper.plan_for_modal_dialog( + "commonDialogWindow", + function (controller) { + controller.window.document + .querySelector("dialog") + .getButton("extra1") + .doCommand(); + } + ); + // Try to close, we should get a prompt to save. + aController.window.goDoCommand("cmd_close"); + windowHelper.wait_for_modal_dialog(); + } else { + aController.window.goDoCommand("cmd_close"); + } + windowHelper.wait_for_window_close(); +} + +/** + * Waits for a new compose window to open. This assumes you have already called + * "windowHelper.plan_for_new_window("msgcompose");" and the command to open + * the compose window itself. + * + * @returns {MozmillController} The loaded window of type "msgcompose" + * wrapped in a MozmillController. + */ +async function async_wait_for_compose_window(aController, aPromise) { + let replyWindow = await aPromise; + return _wait_for_compose_window(aController, replyWindow); +} + +function wait_for_compose_window(aController) { + let replyWindow = windowHelper.wait_for_new_window("msgcompose"); + return _wait_for_compose_window(aController, replyWindow); +} + +function _wait_for_compose_window(aController, replyWindow) { + if (aController === undefined) { + aController = mc; + } + + utils.waitFor( + () => Services.focus.activeWindow == replyWindow.window, + "waiting for the compose window to have focus" + ); + utils.waitFor( + () => replyWindow.window.composeEditorReady, + "waiting for the compose editor to be ready" + ); + utils.sleep(0); + + return replyWindow; +} + +/** + * Fills in the given message recipient/subject/body into the right widgets. + * + * @param aCwc Compose window controller. + * @param aAddr Recipient to fill in. + * @param aSubj Subject to fill in. + * @param aBody Message body to fill in. + * @param inputID The input field to fill in. + */ +function setup_msg_contents( + aCwc, + aAddr, + aSubj, + aBody, + inputID = "toAddrInput" +) { + let pillcount = function () { + return aCwc.window.document.querySelectorAll("mail-address-pill").length; + }; + let targetCount = pillcount(); + if (aAddr.trim()) { + targetCount += aAddr.split(",").filter(s => s.trim()).length; + } + + let input = aCwc.window.document.getElementById(inputID); + utils.sleep(1000); + input.focus(); + EventUtils.sendString(aAddr, aCwc.window); + input.focus(); + + EventUtils.synthesizeKey("VK_RETURN", {}, aCwc.window); + aCwc.window.document.getElementById("msgSubject").focus(); + EventUtils.sendString(aSubj, aCwc.window); + aCwc.window.document.getElementById("messageEditor").focus(); + EventUtils.sendString(aBody, aCwc.window); + + // Wait for the pill(s) to be created. + utils.waitFor( + () => pillcount() == targetCount, + `Creating pill for: ${aAddr}` + ); +} + +/** + * Remove all recipients. + * + * @param aController Compose window controller. + */ +function clear_recipients(aController) { + for (let pill of aController.window.document.querySelectorAll( + "mail-address-pill" + )) { + pill.toggleAttribute("selected", true); + } + aController.window.document + .getElementById("recipientsContainer") + .removeSelectedPills(); +} + +/** + * Return the first available recipient pill. + * + * @param aController - Compose window controller. + */ +function get_first_pill(aController) { + return aController.window.document.querySelector("mail-address-pill"); +} + +/** + * Create and return an nsIMsgAttachment for the passed URL. + * + * @param aUrl the URL for this attachment (either a file URL or a web URL) + * @param aSize (optional) the file size of this attachment, in bytes + */ +function create_msg_attachment(aUrl, aSize) { + let attachment = Cc[ + "@mozilla.org/messengercompose/attachment;1" + ].createInstance(Ci.nsIMsgAttachment); + + attachment.url = aUrl; + if (aSize) { + attachment.size = aSize; + } + + return attachment; +} + +/** + * Add an attachment to the compose window. + * + * @param aController the controller of the composition window in question + * @param aUrl the URL for this attachment (either a file URL or a web URL) + * @param aSize (optional) - the file size of this attachment, in bytes + * @param aWaitAdded (optional) - True to wait for the attachments to be fully added, false otherwise. + */ +function add_attachments(aController, aUrls, aSizes, aWaitAdded = true) { + if (!Array.isArray(aUrls)) { + aUrls = [aUrls]; + } + + if (!Array.isArray(aSizes)) { + aSizes = [aSizes]; + } + + let attachments = []; + + for (let [i, url] of aUrls.entries()) { + attachments.push(create_msg_attachment(url, aSizes[i])); + } + + let attachmentsDone = false; + function collectAddedAttachments(event) { + Assert.equal(event.detail.length, attachments.length); + attachmentsDone = true; + } + + let bucket = aController.window.document.getElementById("attachmentBucket"); + if (aWaitAdded) { + bucket.addEventListener("attachments-added", collectAddedAttachments, { + once: true, + }); + } + aController.window.AddAttachments(attachments); + if (aWaitAdded) { + utils.waitFor(() => attachmentsDone, "Attachments adding didn't finish"); + } + utils.sleep(0); +} + +/** + * Rename the selected cloud (filelink) attachment + * + * @param aController The controller of the composition window in question. + * @param aName The requested new name for the attachment. + * + */ +function rename_selected_cloud_attachment(aController, aName) { + let bucket = aController.window.document.getElementById("attachmentBucket"); + let attachmentRenamed = false; + let upload = null; + let seenAlert = null; + + function getRenamedUpload(event) { + upload = event.target.cloudFileUpload; + attachmentRenamed = true; + } + + /** @implements {nsIPromptService} */ + let mockPromptService = { + value: "", + prompt(window, title, message, rv) { + rv.value = this.value; + return true; + }, + alert(window, title, message) { + seenAlert = { title, message }; + }, + QueryInterface: ChromeUtils.generateQI(["nsIPromptService"]), + }; + + bucket.addEventListener("attachment-renamed", getRenamedUpload, { + once: true, + }); + + let originalPromptService = Services.prompt; + Services.prompt = mockPromptService; + Services.prompt.value = aName; + aController.window.RenameSelectedAttachment(); + + utils.waitFor( + () => attachmentRenamed || seenAlert, + "Couldn't rename attachment" + ); + Services.prompt = originalPromptService; + + utils.sleep(0); + if (seenAlert) { + return seenAlert; + } + + return upload; +} + +/** + * Convert the selected attachment to a cloud (filelink) attachment + * + * @param aController The controller of the composition window in question. + * @param aProvider The provider account to upload the selected attachment to. + * @param aWaitUploaded (optional) - True to wait for the attachments to be uploaded, false otherwise. + */ +function convert_selected_to_cloud_attachment( + aController, + aProvider, + aWaitUploaded = true +) { + let bucket = aController.window.document.getElementById("attachmentBucket"); + let uploads = []; + let attachmentsSelected = + aController.window.gAttachmentBucket.selectedItems.length; + let attachmentsSubmitted = 0; + let attachmentsConverted = 0; + + Assert.equal( + attachmentsSelected, + 1, + "Exactly one attachment should be scheduled for conversion." + ); + + function collectConvertingAttachments(event) { + let item = event.target; + let img = item.querySelector("img.attachmentcell-icon"); + Assert.equal( + img.src, + "chrome://global/skin/icons/loading.png", + "Icon should be the spinner during conversion." + ); + + attachmentsSubmitted++; + if (attachmentsSubmitted == attachmentsSelected) { + bucket.removeEventListener( + "attachment-uploading", + collectConvertingAttachments + ); + bucket.removeEventListener( + "attachment-moving", + collectConvertingAttachments + ); + } + } + + function collectConvertedAttachment(event) { + let item = event.target; + let img = item.querySelector("img.attachmentcell-icon"); + Assert.equal( + img.src, + item.cloudIcon, + "Cloud icon should be used after conversion has finished." + ); + + attachmentsConverted++; + if (attachmentsConverted == attachmentsSelected) { + item.removeEventListener( + "attachment-uploaded", + collectConvertedAttachment + ); + item.removeEventListener("attachment-moved", collectConvertedAttachment); + } + } + + bucket.addEventListener("attachment-uploading", collectConvertingAttachments); + bucket.addEventListener("attachment-moving", collectConvertingAttachments); + aController.window.convertSelectedToCloudAttachment(aProvider); + utils.waitFor( + () => attachmentsSubmitted == attachmentsSelected, + "Couldn't start converting all attachments" + ); + + if (aWaitUploaded) { + bucket.addEventListener("attachment-uploaded", collectConvertedAttachment); + bucket.addEventListener("attachment-moved", collectConvertedAttachment); + + uploads = gMockCloudfileManager.resolveUploads(); + utils.waitFor( + () => attachmentsConverted == attachmentsSelected, + "Attachments uploading didn't finish" + ); + } + + utils.sleep(0); + return uploads; +} + +/** + * Add a cloud (filelink) attachment to the compose window. + * + * @param aController - The controller of the composition window in question. + * @param aProvider - The provider account to upload to, with files to be uploaded. + * @param [aWaitUploaded] - True to wait for the attachments to be uploaded, + * false otherwise. + * @param [aExpectedAlerts] - The number of expected alert prompts. + */ +function add_cloud_attachments( + aController, + aProvider, + aWaitUploaded = true, + aExpectedAlerts = 0 +) { + let bucket = aController.window.document.getElementById("attachmentBucket"); + let uploads = []; + let seenAlerts = []; + + let attachmentsAdded = 0; + let attachmentsSubmitted = 0; + let attachmentsUploaded = 0; + + function collectAddedAttachments(event) { + attachmentsAdded = event.detail.length; + if (!aExpectedAlerts) { + bucket.addEventListener( + "attachment-uploading", + collectUploadingAttachments + ); + } + } + + function collectUploadingAttachments(event) { + let item = event.target; + let img = item.querySelector("img.attachmentcell-icon"); + Assert.equal( + img.src, + "chrome://global/skin/icons/loading.png", + "Icon should be the spinner during upload." + ); + + attachmentsSubmitted++; + if (attachmentsSubmitted == attachmentsAdded) { + bucket.removeEventListener( + "attachment-uploading", + collectUploadingAttachments + ); + } + } + + function collectUploadedAttachments(event) { + let item = event.target; + let img = item.querySelector("img.attachmentcell-icon"); + Assert.equal( + img.src, + item.cloudIcon, + "Cloud icon should be used after upload has finished." + ); + + attachmentsUploaded++; + if (attachmentsUploaded == attachmentsAdded) { + bucket.removeEventListener( + "attachment-uploaded", + collectUploadedAttachments + ); + } + } + + /** @implements {nsIPromptService} */ + let mockPromptService = { + alert(window, title, message) { + seenAlerts.push({ title, message }); + }, + QueryInterface: ChromeUtils.generateQI(["nsIPromptService"]), + }; + + bucket.addEventListener("attachments-added", collectAddedAttachments, { + once: true, + }); + + let originalPromptService = Services.prompt; + Services.prompt = mockPromptService; + aController.window.attachToCloudNew(aProvider); + utils.waitFor( + () => + (!aExpectedAlerts && + attachmentsAdded > 0 && + attachmentsAdded == attachmentsSubmitted) || + (aExpectedAlerts && seenAlerts.length == aExpectedAlerts), + "Couldn't attach attachments for upload" + ); + + Services.prompt = originalPromptService; + if (seenAlerts.length > 0) { + return seenAlerts; + } + + if (aWaitUploaded) { + bucket.addEventListener("attachment-uploaded", collectUploadedAttachments); + uploads = gMockCloudfileManager.resolveUploads(); + utils.waitFor( + () => attachmentsAdded == attachmentsUploaded, + "Attachments uploading didn't finish" + ); + } + utils.sleep(0); + return uploads; +} + +/** + * Delete an attachment from the compose window + * + * @param aComposeWindow the composition window in question + * @param aIndex the index of the attachment in the attachment pane + */ +function delete_attachment(aComposeWindow, aIndex) { + let bucket = + aComposeWindow.window.document.getElementById("attachmentBucket"); + let node = bucket.querySelectorAll("richlistitem.attachmentItem")[aIndex]; + + EventUtils.synthesizeMouseAtCenter(node, {}, node.ownerGlobal); + aComposeWindow.window.RemoveSelectedAttachment(); +} + +/** + * Helper function returns the message body element of a composer window. + * + * @param aController the controller for a compose window. + */ +function get_compose_body(aController) { + let mailBody = aController.window.document + .getElementById("messageEditor") + .contentDocument.querySelector("body"); + if (!mailBody) { + throw new Error("Compose body not found!"); + } + return mailBody; +} + +/** + * Given some compose window controller, type some text into that composer, + * pressing enter after each line except for the last. + * + * @param aController a compose window controller. + * @param aText an array of strings to type. + */ +function type_in_composer(aController, aText) { + // If we have any typing to do, let's do it. + let frame = aController.window.document.getElementById("messageEditor"); + for (let [i, aLine] of aText.entries()) { + frame.focus(); + EventUtils.sendString(aLine, aController.window); + if (i < aText.length - 1) { + frame.focus(); + EventUtils.synthesizeKey("VK_RETURN", {}, aController.window); + } + } +} + +/** + * Given some starting node aStart, ensure that aStart is a text node which + * has a value matching the last value of the aText string array, and has + * a br node immediately preceding it. Repeated for each subsequent string + * of the aText array (working from end to start). + * + * @param aStart the first node to check + * @param aText an array of strings that should be checked for in reverse + * order (so the last element of the array should be the first + * text node encountered, the second last element of the array + * should be the next text node encountered, etc). + */ +function assert_previous_text(aStart, aText) { + let textNode = aStart; + for (let i = aText.length - 1; i >= 0; --i) { + if (textNode.nodeType != kTextNodeType) { + throw new Error( + "Expected a text node! Node type was: " + textNode.nodeType + ); + } + + if (textNode.nodeValue != aText[i]) { + throw new Error( + "Unexpected inequality - " + textNode.nodeValue + " != " + aText[i] + ); + } + + // We expect a BR preceding each text node automatically, except + // for the last one that we reach. + if (i > 0) { + let br = textNode.previousSibling; + + if (br.localName != "br") { + throw new Error( + "Expected a BR node - got a " + br.localName + "instead." + ); + } + + textNode = br.previousSibling; + } + } + return textNode; +} + +/** + * Helper to get the raw contents of a message. It only reads the first 64KiB. + * + * @param aMsgHdr nsIMsgDBHdr addressing a message which will be returned as text. + * @param aCharset Charset to use to decode the message. + * + * @returns String with the message source. + */ +async function get_msg_source(aMsgHdr, aCharset = "") { + let msgUri = aMsgHdr.folder.getUriForMsg(aMsgHdr); + + let content = await new Promise((resolve, reject) => { + let streamListener = { + QueryInterface: ChromeUtils.generateQI(["nsIStreamListener"]), + sis: Cc["@mozilla.org/scriptableinputstream;1"].createInstance( + Ci.nsIScriptableInputStream + ), + content: "", + onDataAvailable(request, inputStream, offset, count) { + this.sis.init(inputStream); + this.content += this.sis.read(count); + }, + onStartRequest(request) {}, + onStopRequest(request, statusCode) { + this.sis.close(); + if (Components.isSuccessCode(statusCode)) { + resolve(this.content); + } else { + reject(new Error(statusCode)); + } + }, + }; + MailServices.messageServiceFromURI(msgUri).streamMessage( + msgUri, + streamListener, + null, + null, + false, + "", + false + ); + }); + + if (!aCharset) { + return content; + } + + let buffer = Uint8Array.from(content, c => c.charCodeAt(0)); + return new TextDecoder(aCharset).decode(buffer); +} + +/** + * Helper class for performing formatted editing on the composition message. + */ +class FormatHelper { + /** + * Create the helper for the given composition window. + * + * @param {Window} win - The composition window. + */ + constructor(win) { + this.window = win; + /** The Format menu. */ + this.formatMenu = this._getById("formatMenuPopup"); + + /** The Font sub menu of {@link FormatHelper#formatMenu}. */ + this.fontMenu = this._getById("fontFaceMenuPopup"); + /** The menu items below the Font menu. */ + this.fontMenuItems = Array.from(this.fontMenu.querySelectorAll("menuitem")); + /** The (font) Size sub menu of {@link FormatHelper#formatMenu}. */ + this.sizeMenu = this._getById("fontSizeMenuPopup"); + /** The menu items below the Size menu. */ + this.sizeMenuItems = Array.from( + // Items without a value are the increase/decrease items. + this.sizeMenu.querySelectorAll("menuitem[value]") + ); + /** The Text Style sub menu of {@link FormatHelper#formatMenu}. */ + this.styleMenu = this._getById("fontStyleMenuPopup"); + /** The menu items below the Text Style menu. */ + this.styleMenuItems = Array.from( + this.styleMenu.querySelectorAll("menuitem") + ); + /** The Paragraph (state) sub menu of {@link FormatHelper#formatMenu}. */ + this.paragraphStateMenu = this._getById("paragraphMenuPopup"); + /** The menu items below the Paragraph menu. */ + this.paragraphStateMenuItems = Array.from( + this.paragraphStateMenu.querySelectorAll("menuitem") + ); + + /** The toolbar paragraph state selector button. */ + this.paragraphStateSelector = this._getById("ParagraphSelect"); + /** The toolbar paragraph state selector menu. */ + this.paragraphStateSelectorMenu = this._getById("ParagraphPopup"); + /** The toolbar font face selector button. */ + this.fontSelector = this._getById("FontFaceSelect"); + /** The toolbar font face selector menu. */ + this.fontSelectorMenu = this._getById("FontFacePopup"); + /** The toolbar font size selector button. */ + this.sizeSelector = this._getById("AbsoluteFontSizeButton"); + /** The toolbar font size selector menu. */ + this.sizeSelectorMenu = this._getById("AbsoluteFontSizeButtonPopup"); + /** The menu items below the toolbar font size selector. */ + this.sizeSelectorMenuItems = Array.from( + this.sizeSelectorMenu.querySelectorAll("menuitem") + ); + + /** The toolbar foreground color selector. */ + this.colorSelector = this._getById("TextColorButton"); + /** The Format foreground color item. */ + this.colorMenuItem = this._getById("fontColor"); + + /** The toolbar increase font size button. */ + this.increaseSizeButton = this._getById("IncreaseFontSizeButton"); + /** The toolbar decrease font size button. */ + this.decreaseSizeButton = this._getById("DecreaseFontSizeButton"); + /** The increase font size menu item. */ + this.increaseSizeMenuItem = this._getById("menu_increaseFontSize"); + /** The decrease font size menu item. */ + this.decreaseSizeMenuItem = this._getById("menu_decreaseFontSize"); + + /** The toolbar bold button. */ + this.boldButton = this._getById("boldButton"); + /** The toolbar italic button. */ + this.italicButton = this._getById("italicButton"); + /** The toolbar underline button. */ + this.underlineButton = this._getById("underlineButton"); + + /** The toolbar remove text styling button. */ + this.removeStylingButton = this._getById("removeStylingButton"); + /** The remove text styling menu item. */ + this.removeStylingMenuItem = this._getById("removeStylesMenuitem"); + + this.messageEditor = this._getById("messageEditor"); + /** The Window of the message content. */ + this.messageWindow = this.messageEditor.contentWindow; + /** The Document of the message content. */ + this.messageDocument = this.messageEditor.contentDocument; + /** The Body of the message content. */ + this.messageBody = this.messageDocument.body; + + let styleDataMap = new Map([ + ["bold", { tag: "B" }], + ["italic", { tag: "I" }], + ["underline", { tag: "U" }], + ["strikethrough", { tag: "STRIKE" }], + ["superscript", { tag: "SUP" }], + ["subscript", { tag: "SUB" }], + ["tt", { tag: "TT" }], + // ["nobreak", { tag: "NOBR" }], // Broken after bug 1806330. Why? + ["em", { tag: "EM", linked: "italic" }], + ["strong", { tag: "STRONG", linked: "bold" }], + ["cite", { tag: "CITE", implies: "italic" }], + ["abbr", { tag: "ABBR" }], + ["acronym", { tag: "ACRONYM" }], + ["code", { tag: "CODE", implies: "tt" }], + ["samp", { tag: "SAMP", implies: "tt" }], + ["var", { tag: "VAR", implies: "italic" }], + ]); + styleDataMap.forEach((data, name) => { + data.item = this.getStyleMenuItem(name); + data.name = name; + }); + styleDataMap.forEach((data, name, map) => { + // Reference the object rather than the name. + if (data.linked) { + data.linked = map.get(data.linked); + Assert.ok(data.linked, `Found linked for ${name}`); + } + if (data.implies) { + data.implies = map.get(data.implies); + Assert.ok(data.implies, `Found implies for ${name}`); + } + }); + /** + * @typedef StyleData + * @property {string} name - The style name. + * @property {string} tag - The tagName for the corresponding HTML element. + * @property {MozMenuItem} item - The corresponding menu item in the + * styleMenu. + * @property {StyleData} [linked] - The style that is linked to this style. + * If this style is set, the linked style is shown as also set. If the + * linked style is unset, so is this style. + * @property {StyleData} [implies] - The style that is implied by this + * style. If this style is set, the implied style is shown as also set. + */ + /** + * Data for the various text styles. Maps from the style name to its data. + * + * @type {Map<string, StyleData>} + */ + this.styleDataMap = styleDataMap; + + /** + * A list of common font families available in Thunderbird. Excludes the + * Variable Width ("") and Fixed Width ("monospace") fonts. + * + * @type {[string]} + */ + this.commonFonts = [ + "Helvetica, Arial, sans-serif", + "Times New Roman, Times, serif", + "Courier New, Courier, monospace", + ]; + + /** The default font size that corresponds to no <font> being applied. */ + this.NO_SIZE = 3; + /** The maximum font size. */ + this.MAX_SIZE = 6; + /** The minimum font size. */ + this.MIN_SIZE = 1; + } + + _getById(id) { + return this.window.document.getElementById(id); + } + + /** + * Move focus to the message area. The message needs to be focused for most + * of the interactive methods to work. + */ + focusMessage() { + EventUtils.synthesizeMouseAtCenter(this.messageEditor, {}, this.window); + } + + /** + * Type some text into the message area. + * + * @param {string} text - A string of printable characters to type. + */ + async typeInMessage(text) { + EventUtils.sendString(text, this.messageWindow); + // Wait one loop to be similar to a user. + await TestUtils.waitForTick(); + } + + /** + * Simulate pressing enter/return in the message area. + * + * @param {boolean} [shift = false] - Whether to hold shift at the same time. + */ + async typeEnterInMessage(shift = false) { + EventUtils.synthesizeKey( + "VK_RETURN", + { shiftKey: shift }, + this.messageWindow + ); + await TestUtils.waitForTick(); + } + + /** + * Delete the current selection in the message window (using backspace). + */ + async deleteSelection() { + EventUtils.synthesizeKey("VK_BACK_SPACE", {}, this.messageWindow); + await TestUtils.waitForTick(); + } + + /** + * Select the entire message. + */ + async selectAll() { + let selection = this.messageWindow.getSelection(); + selection.removeAllRanges(); + + let changePromise = BrowserTestUtils.waitForEvent( + this.messageDocument, + "selectionchange" + ); + + selection.selectAllChildren(this.messageDocument.body); + + await changePromise; + } + + /** + * Select the first paragraph in the message. + */ + async selectFirstParagraph() { + let selection = this.messageWindow.getSelection(); + selection.removeAllRanges(); + + let changePromise = BrowserTestUtils.waitForEvent( + this.messageDocument, + "selectionchange" + ); + + let paragraph = this.messageDocument.body.querySelector("p"); + Assert.ok(paragraph, "Have at least one paragraph"); + selection.selectAllChildren(paragraph); + + await changePromise; + } + + /** + * Delete the entire message. + * + * Note, this currently deletes the paragraph state (see Bug 1715076). + */ + async deleteAll() { + await this.selectAll(); + await this.deleteSelection(); + } + + /** + * Empty the message paragraph. + */ + async emptyParagraph() { + await this.selectFirstParagraph(); + await this.deleteSelection(); + let p = this.messageDocument.body.querySelector("p"); + Assert.equal(p.textContent, "", "should have emptied p"); + } + + /** + * Tags that correspond to inline styling (in upper case). + * + * @type {[string]} + */ + static inlineStyleTags = [ + "B", + "I", + "U", + "STRIKE", + "SUP", + "SUB", + "TT", + "NOBR", + "EM", + "STRONG", + "CITE", + "ABBR", + "ACRONYM", + "CODE", + "SAMP", + "VAR", + ]; + /** + * Tags that correspond to block scopes (in upper case). + * + * @type {[string]} + */ + static blockTags = [ + "P", + "PRE", + "ADDRESS", + "H1", + "H2", + "H3", + "H4", + "H5", + "H6", + ]; + + /** + * @param {Node} node - The node to test. + * + * @returns {boolean} Whether the node is considered a block. + */ + static isBlock(node) { + return this.blockTags.includes(node.tagName); + } + + /** + * @param {Node} node - The node to test. + * + * @returns {boolean} Whether the node is considered inline styling. + */ + static isInlineStyle(node) { + return this.inlineStyleTags.includes(node.tagName); + } + + /** + * @param {Node} node - The node to test. + * + * @returns {boolean} Whether the node is considered a font node. + */ + static isFont(node) { + return node.tagName === "FONT"; + } + + /** + * @param {Node} node - The node to test. + * + * @returns {boolean} Whether the node is considered a break. + */ + static isBreak(node) { + return node.tagName === "BR"; + } + + /** + * A leaf of the message body. Actual leaves of the HTMLBodyElement will have + * a corresponding Leaf (corresponding to the "break", "text" and "empty" + * types), with the exception of empty block elements. These leaves are + * ordered with respect to the corresponding childNode ordering. In addition, + * every block element will have two corresponding leaves: one for the start + * of the block ("block-start") that is ordered just before its children; and + * one for the end of the block ("block-end") that is ordered just after its + * children. Essentially, you can think of the opening and closing tags of the + * block as leaves of the message body. + * + * @typedef Leaf + * @property {"break"|"block-start"|"block-end"|"text"|"empty"} type - + * The leaf type. + * @property {Node} node - The associated node in the document. + */ + + /** + * Get the first leaf below the given node with respect to Leaf ordering. + * + * @param {Node} node - The node to fetch the first leaf of. + * + * @returns {Leaf} - The first leaf below the node. + */ + static firstLeaf(node) { + while (true) { + // Starting the block scope. + if (this.isBlock(node)) { + return { type: "block-start", node }; + } + let child = node.firstChild; + if (child) { + node = child; + } else { + break; + } + } + if (Text.isInstance(node)) { + return { type: "text", node }; + } else if (this.isBreak(node)) { + return { type: "break", node }; + } + return { type: "empty", node }; + } + + /** + * Get the next Leaf that follows the given Leaf in the ordering. + * + * @param {Node} root - The root of the tree to find leaves from. + * @param {Leaf} leaf - The leaf to search from. + * + * @returns {Leaf|null} - The next Leaf under the root that follows the given + * Leaf, or null if the given leaf was the last one. + */ + static nextLeaf(root, leaf) { + if (leaf.type === "block-start") { + // Enter within the block scope. + let child = leaf.node.firstChild; + if (!child) { + return { type: "block-end", node }; + } + return this.firstLeaf(child); + } + // Find the next branch of the tree. + let node = leaf.node; + let sibling; + while (true) { + if (node === root) { + return null; + } + // Move to the next branch, if there is one. + sibling = node.nextSibling; + if (sibling) { + break; + } + // Otherwise, move back up the current branch. + node = node.parentNode; + // Leaving the block scope. + if (this.isBlock(node)) { + return { type: "block-end", node }; + } + } + // Travel to the first leaf of the branch. + return this.firstLeaf(sibling); + } + + /** + * Select some text in the message body. + * + * Note, the start and end values refer to offsets from the start of the + * message, and they count the spaces *between* string characters in the + * message. + * + * A single newline will also count 1 towards the offset. This can refer to + * either the start or end of a block (such as a <p>), or an explicit line + * break (<br>). Note, as an exception, line breaks that do not produce a new + * line visually (breaks at the end of a block, or breaks in the body scope + * between a text node and the start of a block) do not count. + * + * You can either choose to select in a forward direction or a backward + * direction. When no end parameter is given, this corresponds to if a user + * approaches a position in the message by moving the text cursor forward or + * backward (using the arrow keys). Otherwise, this refers to the direction in + * which the selection was formed (using shift + arrow keys or dragging). + * + * @param {number} start - The position to start selecting from. + * @param {number|null} [end = null] - The position to end selecting from, + * after start, or null to select the same position as the start. + * @param {boolean} [forward = true] - Whether to select in the forward or + * backward direction. + */ + async selectTextRange(start, end = null, forward = true) { + let selectionTargets = [{ position: start }]; + if (end !== null) { + Assert.ok( + end >= start, + `End of selection (${end}) should be after the start (${start})` + ); + selectionTargets.push({ position: end }); + } + + let cls = this.constructor; + let root = this.messageBody; + let prevLeaf = null; + let leaf = cls.firstLeaf(root); + let total = 0; + // NOTE: Only the leaves of the root will contribute to the total, which is + // why we only need to traverse them. + // Search the tree until we find the target nodes, or run out of leaves. + while (leaf && selectionTargets.some(target => !target.node)) { + // Look ahead at the next leaf. + let nextLeaf = cls.nextLeaf(root, leaf); + switch (leaf.type) { + case "text": + // Each character in the text content counts towards the total. + let textLength = leaf.node.textContent.length; + total += textLength; + + for (let target of selectionTargets) { + if (target.node) { + continue; + } + if (total === target.position) { + // If the next leaf is a text node, then the start of the + // selection is between the end of this node and the start of + // the next node. If selecting forward, we prefer the end of the + // first node. Otherwise, we prefer the start of the next node. + // If the next node is not a text node (such as a break or the end + // of a block), we end at the current node. + if (forward || nextLeaf?.type !== "text") { + target.node = leaf.node; + target.offset = textLength; + } + // Else, let the next (text) leaf set the node and offset. + } else if (total > target.position) { + target.node = leaf.node; + // Difference between the selection start and the start of the + // node. + target.offset = target.position - total + textLength; + } + } + break; + case "block-start": + // Block start is a newline if the previous leaf was a text node in + // the body scope. + // Note that it is sufficient to test if the previous leaf was a text + // node, because if such a text node was not in the body scope we + // would have visited "block-end" in-between. + // If the body scope ended in a break we would have already have a + // newline, so there is no need to double count it. + if (prevLeaf?.type === "text") { + // If the total was already equal to a target.position, then the + // previous text node would have handled it in the + // (total === target.position) + // case above. + // So we can safely increase the total and let the next leaf handle + // it. + total += 1; + } + break; + case "block-end": + // Only create a newline if non-empty. + if (prevLeaf?.type !== "block-start") { + for (let target of selectionTargets) { + if (!target.node && total === target.position) { + // This should only happen for blocks that contain no text, such + // as a block that only contains a break. + target.node = leaf.node; + target.offset = leaf.node.childNodes.length - 1; + } + } + // Let the next leaf handle it. + total += 1; + } + break; + case "break": + // Only counts as a newline if it is not trailing in the body or block + // scope. + if (nextLeaf && nextLeaf.type !== "block-end") { + for (let target of selectionTargets) { + if (!target.node && total === target.position) { + // This should only happen for breaks that are at the start of a + // block. + // The break has no content, so the parent is used as the + // target. + let parentNode = leaf.node.parentNode; + target.node = parentNode; + let index = 0; + while (parentNode[index] !== leaf.node) { + index += 1; + } + target.offset = index; + } + } + total += 1; + } + break; + // Ignore type === "empty" + } + prevLeaf = leaf; + leaf = nextLeaf; + } + + Assert.ok( + selectionTargets.every(target => target.node), + `Found selection from ${start} to ${end === null ? start : end}` + ); + + // Clear the current selection. + let selection = this.messageWindow.getSelection(); + selection.removeAllRanges(); + + // Create the new one. + let range = this.messageDocument.createRange(); + range.setStart(selectionTargets[0].node, selectionTargets[0].offset); + if (end !== null) { + range.setEnd(selectionTargets[1].node, selectionTargets[1].offset); + } else { + range.setEnd(selectionTargets[0].node, selectionTargets[0].offset); + } + + let changePromise = BrowserTestUtils.waitForEvent( + this.messageDocument, + "selectionchange" + ); + selection.addRange(range); + + await changePromise; + } + + /** + * Select the given text and delete it. See selectTextRange to know how to set + * the parameters. + * + * @param {number} start - The position to start selecting from. + * @param {number} end - The position to end selecting from, after start. + */ + async deleteTextRange(start, end) { + await this.selectTextRange(start, end); + await this.deleteSelection(); + } + + /** + * @typedef BlockSummary + * @property {string} block - The tag name of the node. + * @property {(StyledTextSummary|string)[]} content - The regions of styled + * text content, ordered the same as in the document structure. String + * entries are equivalent to StyledTextSummary object with no set styling + * properties. + */ + + /** + * @typedef StyledTextSummary + * @property {string} text - The text for this region. + * @property {Set<string>} [tags] - The tags applied to this region, if any. + * When passing in an object, you can use an Array of strings instead, which + * will be converted into a Set when needed. + * @property {string} [font] - The font family applied to this region, if any. + * @property {number} [size] - The font size applied to this region, if any. + * @property {string} [color] - The font color applied to this region, if any. + */ + + /** + * Test if the two sets of tags are equal. undefined tags count as an empty + * set. + * + * @param {Set<string>|undefined} tags - A set of tags. + * @param {Set<string>|undefined} cmp - A set to compare against. + * + * @returns {boolean} - Whether the two sets are equal. + */ + static equalTags(tags, cmp) { + if (!tags || tags.size === 0) { + return !cmp || cmp.size === 0; + } + if (!cmp) { + return false; + } + if (tags.size !== cmp.size) { + return false; + } + for (let t of tags) { + if (!cmp.has(t)) { + return false; + } + } + return true; + } + + /** + * Get a summary of the message body content. + * + * Note that the summary will exclude break nodes that do not produce a + * newline. That is break nodes between a text node and either: + * + the end of the body, + * + the start of a block, or + * + the end of a block. + * + * @returns {(BlockSummary|StyledTextSummary)[]} - A summary of the body + * content. + */ + getMessageBodyContent() { + let cls = this.constructor; + let bodyNode = this.messageBody; + let bodyContent = []; + let blockNode = null; + let blockContent = null; + let prevLeaf = null; + let leaf = cls.firstLeaf(bodyNode); + // NOTE: Only the leaves of the body will contribute to the content, which + // is why we only need to traverse them. + while (leaf) { + // Look ahead at the next leaf. + let nextLeaf = cls.nextLeaf(bodyNode, leaf); + let isText = leaf.type === "text"; + let isBreak = leaf.type === "break"; + let isEmpty = leaf.type === "empty"; + // Ignore a break node between a text node and either: + // + the end of the body, + // + the start of a block, or + // + the end of a block. + let ignoreBreak = + prevLeaf?.type === "text" && + (!nextLeaf || + nextLeaf.type === "block-start" || + nextLeaf.type === "block-end"); + if (leaf.type === "block-start") { + if (blockNode) { + throw new Error( + `Unexpected ${leaf.node.tagName} within a ${blockNode.tagName}` + ); + } + // Set the block to add content to. + let block = { block: leaf.node.tagName, content: [] }; + blockNode = leaf.node; + blockContent = block.content; + // Add to the content of the body. + bodyContent.push(block); + } else if (leaf.type === "block-end") { + if (!blockNode) { + throw new Error(`Unexpected block end for ${leaf.node.tagName}`); + } + // Remove the block to add content to. + blockNode = null; + blockContent = null; + } else if (isText || isEmpty || (isBreak && !ignoreBreak)) { + let tags; + let font; + let size; + let color; + let ancestorBlock = blockNode || bodyNode; + for ( + // If empty, then we include the styling of the empty element. + let ancestor = isEmpty ? leaf.node : leaf.node.parentNode; + ancestor !== ancestorBlock; + ancestor = ancestor.parentNode + ) { + if (cls.isInlineStyle(ancestor)) { + if (!tags) { + tags = new Set(); + } + tags.add(ancestor.tagName); + } else if (cls.isFont(ancestor)) { + // Prefer attributes from closest <font> ancestor. + if (font === undefined && ancestor.hasAttribute("face")) { + font = ancestor.getAttribute("face"); + } + if (size === undefined && ancestor.hasAttribute("size")) { + size = Number(ancestor.getAttribute("size")); + } + if (color === undefined && ancestor.hasAttribute("color")) { + color = ancestor.getAttribute("color"); + } + } else { + throw new Error(`Unknown format element ${ancestor.tagName}`); + } + } + let text; + if (isBreak) { + text = "<BR>"; + } else if (isText) { + text = leaf.node.textContent; + } else { + // Empty styling elements. + text = ""; + } + + let content = blockContent || bodyContent; + let merged = false; + if (content.length) { + let prevSummary = content[content.length - 1]; + // NOTE: prevSummary may be a block if this leaf lives in the body + // scope. We don't merge in that case. + if ( + !prevSummary.block && + cls.equalTags(prevSummary.tags, tags) && + prevSummary.font === font && + prevSummary.size === size && + prevSummary.color === color + ) { + // Merge into the previous text if this region has the same text + // tags applied to it. + prevSummary.text += text; + merged = true; + } + } + if (!merged) { + let summary = { text }; + summary.tags = tags; + summary.font = font; + summary.size = size; + summary.color = color; + content.push(summary); + } + } + prevLeaf = leaf; + leaf = nextLeaf; + } + + if (blockNode) { + throw new Error(`Unexpected end of body within a ${blockNode.tagName}`); + } + + return bodyContent; + } + + /** + * Test that the current message body matches the given content. + * + * Note that the test is performed against a simplified version of the message + * body, where adjacent equivalent styling tags are merged together, and <BR> + * elements that do not produce a newline are ignored (see + * {@link FormatHelper#getMessageBodyContent}). This is to capture what the + * message would appear as to a user, rather than the exact details of the + * document structure. + * + * To represent breaks between text regions, simply include a "<BR>" in the + * expected text string. As such, the test cannot distinguish between a "<BR>" + * textContent and a break element, so do not use "<BR>" within the typed text + * of the message. + * + * @param {(BlockSummary|StyledTextSummary|string)[]} content - The expected + * content, ordered the same as in the document structure. BlockSummary + * objects represent blocks, and will have their own content. + * StyledTextSummary objects represent styled text directly in the body + * scope, and string objects represent un-styled text directly in the body + * scope. + * @param {string} assertMessage - A description of the test. + */ + assertMessageBodyContent(content, assertMessage) { + let cls = this.constructor; + + function message(message, below, index) { + return `${message} (at index ${index} below ${below})`; + } + + function getDifference(node, expect, below, index) { + if (typeof expect === "string") { + expect = { text: expect }; + } + if (expect.text !== undefined) { + // StyledTextSummary + if (node.text === undefined) { + return message("Is not a (styled) text region", below, index); + } + if (node.text !== expect.text) { + return message( + `Different text "${node.text}" vs "${expect.text}"`, + below, + index + ); + } + if (Array.isArray(expect.tags)) { + expect.tags = new Set(expect.tags); + } + if (!cls.equalTags(node.tags, expect.tags)) { + function tagsToString(tags) { + if (!tags) { + return "NONE"; + } + return Array.from(tags).join(","); + } + let have = tagsToString(node.tags); + let wanted = tagsToString(expect.tags); + return message(`Different tags ${have} vs ${wanted}`, below, index); + } + if (node.font !== expect.font) { + return message( + `Different font "${node.font}" vs "${expect.font}"`, + below, + index + ); + } + if (node.size !== expect.size) { + return message( + `Different size ${node.size} vs ${expect.size}`, + below, + index + ); + } + if (node.color !== expect.color) { + return message( + `Different color ${node.color} vs ${expect.color}`, + below, + index + ); + } + return null; + } else if (expect.block !== undefined) { + if (node.block === undefined) { + return message("Is not a block", below, index); + } + if (node.block !== expect.block) { + return message( + `Different block names ${node.block} vs ${expect.block}`, + below, + index + ); + } + let i; + for (i = 0; i < expect.content.length; i++) { + if (i >= node.content.length) { + return message("Missing child", node.block, i); + } + let childDiff = getDifference( + node.content[i], + expect.content[i], + node.block, + i + ); + if (childDiff !== null) { + return childDiff; + } + } + if (i !== node.content.length) { + let extra = ""; + for (; i < node.content.length; i++) { + let child = node.content[i]; + if (child.text !== undefined) { + extra += child.text; + } else { + extra += `<${child.block}/>`; + } + } + return message(`Has extra children: ${extra}`, node.block, i); + } + return null; + } + throw new Error(message("Unrecognised object", below, index)); + } + + let expectBlock = { block: "BODY", content }; + let bodyBlock = { block: "BODY", content: this.getMessageBodyContent() }; + + // We use a single Assert so that we can bail early if there is a + // difference. Only show the first difference found. + Assert.equal( + getDifference(bodyBlock, expectBlock, "HTML", 0), + null, + `${assertMessage}: Should be no difference in body content` + ); + } + + /** + * For debugging, print the message body content, as produced by + * {@link FormatHelper#getMessageBodyContent}. + */ + dumpMessageBodyContent() { + function printTextSummary(textSummary, indent = "") { + let str = `${indent}<text`; + for (let prop in textSummary) { + let value = textSummary[prop]; + switch (prop) { + case "text": + continue; + case "tags": + value = value ? Array.from(value).join(",") : undefined; + break; + } + if (value !== undefined) { + str += ` ${prop}="${value}"`; + } + } + str += `>${textSummary.text}</text>`; + console.log(str); + } + + function printBlockSummary(blockSummary) { + console.log(`<${blockSummary.block}>`); + for (let textSummary of blockSummary.content) { + printTextSummary(textSummary, " "); + } + console.log(`</${blockSummary.block}>`); + } + + for (let summary of this.getMessageBodyContent()) { + if (summary.block !== undefined) { + printBlockSummary(summary); + } else { + printTextSummary(summary); + } + } + } + + /** + * Test that the message body contains a single paragraph block with the + * given content. See {@link FormatHelper#assertMessageBodyContent}. + * + * @param {(StyledTextSummary|string)[]} content - The expected content of the + * paragraph. + * @param {string} assertMessage - A description of the test. + */ + assertMessageParagraph(content, assertMessage) { + this.assertMessageBodyContent([{ block: "P", content }], assertMessage); + } + + /** + * Attempt to show a menu. The menu must be closed when calling. + * + * NOTE: this fails to open a native application menu on mac/osx because it is + * handled and restricted by the OS. + * + * @param {MozMenuPopup} menu - The menu to show. + * + * @returns {boolean} Whether the menu was opened. Otherwise, the menu is still + * closed. + */ + async _openMenuOnce(menu) { + menu = menu.parentNode; + // NOTE: Calling openMenu(true) on a closed menu will put the menu in the + // "showing" state. But this can be cancelled (for some unknown reason) and + // the menu will be put back in the "hidden" state. Therefore we listen to + // both popupshown and popuphidden. See bug 1720174. + // NOTE: This only seems to happen for some platforms, specifically this + // sometimes occurs for the linux64 build on the try server. + // FIXME: Use only BrowserEventUtils.waitForEvent(menu, "popupshown") + let eventPromise = new Promise(resolve => { + let listener = event => { + menu.removeEventListener("popupshown", listener); + menu.removeEventListener("popuphidden", listener); + resolve(event.type); + }; + menu.addEventListener("popupshown", listener); + menu.addEventListener("popuphidden", listener); + }); + menu.openMenu(true); + let eventType = await eventPromise; + return eventType == "popupshown"; + } + + /** + * Show a menu. The menu must be closed when calling. + * + * @param {MozMenuPopup} menu - The menu to show. + */ + async _openMenu(menu) { + if (!(await this._openMenuOnce(menu))) { + // If opening failed, try one more time. See bug 1720174. + Assert.ok( + await this._openMenuOnce(menu), + `Opening ${menu.id} should succeed on a second attempt` + ); + } + } + + /** + * Hide a menu. The menu must be open when calling. + * + * @param {MozMenuPopup} menu - The menu to hide. + */ + async _closeMenu(menu) { + menu = menu.parentNode; + let hiddenPromise = BrowserTestUtils.waitForEvent(menu, "popuphidden"); + menu.openMenu(false); + await hiddenPromise; + } + + /** + * Select a menu item from an open menu. This will also close the menu. + * + * @param {MozMenuItem} item - The item to select. + * @param {MozMenuPopup} menu - The open menu that the item belongs to. + */ + async _selectFromOpenMenu(item, menu) { + menu = menu.parentNode; + let hiddenPromise = BrowserTestUtils.waitForEvent(menu, "popuphidden"); + menu.menupopup.activateItem(item); + await hiddenPromise; + } + + /** + * Open a menu, select one of its items and close the menu. + * + * @param {MozMenuItem} item - The item to select. + * @param {MozMenuPopup} menu - The menu to open, that item belongs to. + */ + async _selectFromClosedMenu(item, menu) { + if (item.disabled) { + await TestUtils.waitForCondition( + () => !item.disabled, + `Waiting for "${item.label}" to be enabled` + ); + } + await this._openMenu(menu); + await this._selectFromOpenMenu(item, menu); + } + + /** + * Close the [Format menu]{@link FormatHelper#formatMenu}, without selecting + * anything. + * + * Note, any open sub menus are also closed. + * + * Note, this method does not currently work on mac/osx because the Format + * menu is part of the native application menu, which cannot be activated + * through mochitests. + */ + async closeFormatMenu() { + // Closing format menu closes the sub menu. + await this._closeMenu(this.formatMenu); + } + + /** + * Select an item directly below the + * [Format menu]{@link FormatHelper#formatMenu}. + * + * Note, the Format menu must be closed before calling. + * + * Note, this method does not currently work on mac/osx because the Format + * menu is part of the native application menu, which cannot be activated + * through mochitests. + * + * @param {MozMenuItem} item - The item to select. + */ + async selectFromFormatMenu(item) { + await this._openMenu(this.formatMenu); + await this._selectFromOpenMenu(item, this.formatMenu); + } + + /** + * Open the [Format menu]{@link FormatHelper#formatMenu} and open one of its + * sub-menus, without selecting anything. + * + * Note, the Format menu must be closed before calling. + * + * Note, this method does not currently work on mac/osx because the Format + * menu is part of the native application menu, which cannot be activated + * through mochitests. + * + * @param {MozMenuPopup} menu - A closed menu below the Format menu to open. + */ + async openFormatSubMenu(menu) { + if ( + !(await this._openMenuOnce(this.formatMenu)) || + !(await this._openMenuOnce(menu)) + ) { + // If opening failed, try one more time. See bug 1720174. + // NOTE: failing to open the sub-menu can cause the format menu to also + // close. But we still make sure the format menu is closed before trying + // again. + if (this.formatMenu.state == "open") { + await this._closeMenu(this.formatMenu); + } + Assert.ok( + await this._openMenuOnce(this.formatMenu), + "Opening format menu should succeed on a second attempt" + ); + Assert.ok( + await this._openMenuOnce(menu), + `Opening format sub-menu ${menu.id} should succeed on a second attempt` + ); + } + } + + /** + * Select an item from a sub-menu of the + * [Format menu]{@link FormatHelper#formatMenu}. The menu is opened before + * selecting. + * + * Note, the Format menu must be closed before calling. + * + * Note, this method does not currently work on mac/osx because the Format + * menu is part of the native application menu, which cannot be activated + * through mochitests. + * + * @param {MozMenuItem} item - The item to select. + * @param {MozMenuPopup} menu - The Format sub-menu that the item belongs to. + */ + async selectFromFormatSubMenu(item, menu) { + if (item.disabled) { + await TestUtils.waitForCondition( + () => !item.disabled, + `Waiting for "${item.label}" to be enabled` + ); + } + await this.openFormatSubMenu(menu); + let hiddenPromise = BrowserTestUtils.waitForEvent( + this.formatMenu, + "popuphidden" + ); + // Selecting from the submenu also closes the parent menu. + await this._selectFromOpenMenu(item, menu); + await hiddenPromise; + } + + /** + * Run a test with the format sub menu open. Before each test attempt, the + * [Format menu]{@link FormatHelper#formatMenu} is opened and so is the given + * sub-menu. After each attempt, the menu is closed. + * + * Note, the Format menu must be closed before calling. + * + * Note, this method does not currently work on mac/osx. + * + * @param {MozMenuPopup} menu - A closed menu below the Format menu to open. + * @param {Function} test - A test to run, without arguments, when the menu is + * open. Should return a truthy value on success. + * @param {string} message - The message to use when asserting the success of + * the test. + * @param {boolean} [wait] - Whether to retry until the test passes. + */ + async assertWithFormatSubMenu(menu, test, message, wait = false) { + let performTest = async () => { + await this.openFormatSubMenu(menu); + let pass = test(); + await this.closeFormatMenu(); + return pass; + }; + if (wait) { + await TestUtils.waitForCondition(performTest, message); + } else { + Assert.ok(await performTest(), message); + } + } + + /** + * Select a paragraph state for the editor, using toolbar selector. + * + * @param {string} state - The state to select. + */ + async selectParagraphState(state) { + await this._selectFromClosedMenu( + this.paragraphStateSelectorMenu.querySelector( + `menuitem[value="${state}"]` + ), + this.paragraphStateSelectorMenu + ); + } + + /** + * Get the menu item corresponding to the given state, that lives in the + * [Paragraph sub-menu]{@link FormatHelper#paragraphStateMenu} below the + * Format menu. + * + * @param {string} state - A state. + * + * @returns {MozMenuItem} - The menu item used for selecting the given state. + */ + getParagraphStateMenuItem(state) { + return this.paragraphStateMenu.querySelector(`menuitem[value="${state}"]`); + } + + /** + * Assert that the editor UI (eventually) shows the given paragraph state. + * + * Note, this method does not currently work on mac/osx. + * + * @param {string|null} state - The expected paragraph state, or null if the + * state should be shown as mixed. + * @param {string} message - A message to use in assertions. + */ + async assertShownParagraphState(state, message) { + if (state === null) { + // In mixed state. + // getAttribute("value") currently returns "", rather than null, so test + // for hasAttribute instead. + await TestUtils.waitForCondition( + () => !this.paragraphStateSelector.hasAttribute("value"), + `${message}: Selector has no value` + ); + } else { + await TestUtils.waitForCondition( + () => this.paragraphStateSelector.value === state, + `${message}: Selector has the value "${state}"` + ); + } + + await this.assertWithFormatSubMenu( + this.paragraphStateMenu, + () => + this.paragraphStateMenuItems.every( + item => + (item.getAttribute("checked") === "true") === (item.value === state) + ), + `${message}: Only state="${state}" menu item should be checked` + ); + } + + /** + * Select a font family for the editor, using the toolbar selector. + * + * @param {string} font - The font family to select. + */ + async selectFont(font) { + await this._selectFromClosedMenu( + this.fontSelectorMenu.querySelector(`menuitem[value="${font}"]`), + this.fontSelectorMenu + ); + } + + /** + * Get the menu item corresponding to the given font family, that lives in + * the [Font sub-menu]{@link FormatHelper#fontMenu} below the Format menu. + * + * @param {string} font - A font family. + * + * @returns {MozMenuItem} - The menu item used for selecting the given font + * family. + */ + getFontMenuItem(font) { + return this.fontMenu.querySelector(`menuitem[value="${font}"]`); + } + + /** + * Assert that the editor UI (eventually) shows the given font family. + * + * Note, this method does not currently work on mac/osx. + * + * @param {string|null} font - The expected font family, or null if the state + * should be shown as mixed. + * @param {string} message - A message to use in assertions. + */ + async assertShownFont(font, message) { + if (font === null) { + // In mixed state. + // getAttribute("value") currently returns "", rather than null, so test + // for hasAttribute instead. + await TestUtils.waitForCondition( + () => !this.fontSelector.hasAttribute("value"), + `${message}: Selector has no value` + ); + } else { + await TestUtils.waitForCondition( + () => this.fontSelector.value === font, + `${message}: Selector value is "${font}"` + ); + } + + await this.assertWithFormatSubMenu( + this.fontMenu, + () => + this.fontMenuItems.every( + item => + (item.getAttribute("checked") === "true") === (item.value === font) + ), + `${message}: Only font="${font}" menu item should be checked` + ); + } + + /** + * Select a font size for the editor, using the toolbar selector. + * + * @param {number} size - The font size to select. + */ + async selectSize(size) { + await this._selectFromClosedMenu( + this.sizeSelectorMenu.querySelector(`menuitem[value="${size}"]`), + this.sizeSelectorMenu + ); + } + + /** + * Assert that the editor UI (eventually) shows the given font size. + * + * Note, this method does not currently work on mac/osx. + * + * @param {number|null} size - The expected font size, or null if the state + * should be shown as mixed. + * @param {string} message - A message to use in assertions. + */ + async assertShownSize(size, message) { + size = size?.toString(); + // Test in Format Menu. + await this.assertWithFormatSubMenu( + this.sizeMenu, + () => + this.sizeMenuItems.every( + item => + (item.getAttribute("checked") === "true") === (item.value === size) + ), + `${message}: Only size=${size} Format menu item should be checked` + // Don't have to wait for size menu. + ); + // Test the same in the Toolbar selector. + await this._openMenu(this.sizeSelectorMenu); + Assert.ok( + this.sizeSelectorMenuItems.every( + item => + (item.getAttribute("checked") === "true") === (item.value === size) + ), + `${message}: Only size=${size} Toolbar menu item should be checked` + ); + await this._closeMenu(this.sizeSelectorMenu); + } + + /** + * Get the menu item corresponding to the given font size, that lives in + * the [Size sub-menu]{@link FormatHelper#sizeMenu} below the Format menu. + * + * @param {number} size - A font size. + * + * @returns {MozMenuItem} - The menu item used for selecting the given font + * size. + */ + getSizeMenuItem(size) { + return this.sizeMenu.querySelector(`menuitem[value="${size}"]`); + } + + /** + * Select the given color when the color picker dialog is opened. + * + * Note, the dialog will have to be opened separately to this method. Normally + * after this method, but before awaiting on the promise. + * + * @property {string|null} - The color to choose, or null to choose the default. + * + * @returns {Promise} - The promise to await on once the dialog is triggered. + */ + async selectColorInDialog(color) { + return BrowserTestUtils.promiseAlertDialog( + null, + "chrome://messenger/content/messengercompose/EdColorPicker.xhtml", + { + callback: async win => { + if (color === null) { + win.document.getElementById("DefaultColorButton").click(); + } else { + win.document.getElementById("ColorInput").value = color; + } + win.document.querySelector("dialog").getButton("accept").click(); + }, + } + ); + } + + /** + * Select a font color for the editor, using the toolbar selector. + * + * @param {string} font - The font color to select. + */ + async selectColor(color) { + let selector = this.selectColorInDialog(color); + this.colorSelector.click(); + await selector; + } + + /** + * Assert that the editor UI (eventually) shows the given font color. + * + * @param {{value: string, rgb: [number]}|""|null} color - The expected font + * color. You should supply both the value, as set in the test, and its + * corresponding RGB numbers. Alternatively, give "" to assert the default + * color, or null to assert that the font color is shown as mixed. + * @param {string} message - A message to use in assertions. + */ + async assertShownColor(color, message) { + if (color === "") { + color = { value: "", rgb: [0, 0, 0] }; + } + + let rgbRegex = /^rgb\(([0-9]+), ([0-9]+), ([0-9]+)\)$/; + let testOnce = foundColor => { + if (color === null) { + return foundColor === "mixed"; + } + // color can either be the value or an rgb. + let foundRgb = rgbRegex.exec(foundColor); + if (foundRgb) { + foundRgb = foundRgb.slice(1).map(s => Number(s)); + return ( + foundRgb[0] === color.rgb[0] && + foundRgb[1] === color.rgb[1] && + foundRgb[2] === color.rgb[2] + ); + } + return foundColor === color.value; + }; + + let name = color === null ? '"mixed"' : `"${color.value}"`; + let foundColor = this.colorSelector.getAttribute("color"); + if (testOnce(foundColor)) { + Assert.ok( + true, + `${message}: Found color "${foundColor}" should match ${name}` + ); + return; + } + await TestUtils.waitForCondition(() => { + let colorNow = this.colorSelector.getAttribute("color"); + if (colorNow !== foundColor) { + foundColor = colorNow; + return true; + } + return false; + }, `${message}: Waiting for the color to change from ${foundColor}`); + Assert.ok( + testOnce(foundColor), + `${message}: Changed color "${foundColor}" should match ${name}` + ); + } + + /** + * Get the menu item corresponding to the given style, that lives in the + * [Text Style sub-menu]{@link FormatHelper#styleMenu} below the Format menu. + * + * @param {string} style - A style. + * + * @returns {MozMenuItem} - The menu item used for selecting the given style. + */ + getStyleMenuItem(style) { + return this.styleMenu.querySelector(`menuitem[observes="cmd_${style}"]`); + } + + /** + * Select the given style from the [Style menu]{@link FormatHelper#styleMenu}. + * + * Note, this method does not currently work on mac/osx. + * + * @param {StyleData} style - The style data for the style to select. + */ + async selectStyle(styleData) { + await this.selectFromFormatSubMenu(styleData.item, this.styleMenu); + } + + /** + * Assert that the editor UI (eventually) shows the given text styles. + * + * Note, this method does not currently work on mac/osx. + * + * Implied styles (see {@link StyleData#linked} and {@linj StyleData#implies}) + * will be automatically checked for from the given styles. + * + * @param {[(StyleData|string)]|StyleData|string|null} styleSet - The styles + * to assert as shown. If none should be shown, given null. Otherwise, + * styles can either be specified by their style name (as used in + * {@link FormatHelper#styleDataMap}) or by the style data directly. Either + * an array of styles can be passed, or a single style. + * @param {string} message - A message to use in assertions. + */ + async assertShownStyles(styleSet, message) { + let expectItems = []; + let expectString; + let isBold = false; + let isItalic = false; + let isUnderline = false; + if (styleSet) { + expectString = "Only "; + let first = true; + let addSingleStyle = data => { + if (!data) { + return; + } + isBold = isBold || data.name === "bold"; + isItalic = isItalic || data.name === "italic"; + isUnderline = isUnderline || data.name === "underline"; + expectItems.push(data.item); + if (first) { + first = false; + } else { + expectString += ", "; + } + expectString += data.name; + }; + let addStyle = style => { + if (typeof style === "string") { + style = this.styleDataMap.get(style); + } + addSingleStyle(style); + addSingleStyle(style.linked); + addSingleStyle(style.implies); + }; + + if (Array.isArray(styleSet)) { + styleSet.forEach(style => addStyle(style)); + } else { + addStyle(styleSet); + } + } else { + expectString = "None"; + } + await this.assertWithFormatSubMenu( + this.styleMenu, + () => { + let checkedIds = this.styleMenuItems + .filter(i => i.getAttribute("checked") === "true") + .map(m => m.id); + if (expectItems.length != checkedIds.length) { + dump( + `Expected: ${expectItems.map(i => i.id)}, Actual: ${checkedIds}\n` + ); + } + return this.styleMenuItems.every( + item => + (item.getAttribute("checked") === "true") === + expectItems.includes(item) + ); + }, + `${message}: ${expectString} should be checked`, + true + ); + + // Check the toolbar buttons. + Assert.equal( + this.boldButton.checked, + isBold, + `${message}: Bold button should be ${isBold ? "" : "un"}checked` + ); + Assert.equal( + this.italicButton.checked, + isItalic, + `${message}: Italic button should be ${isItalic ? "" : "un"}checked` + ); + Assert.equal( + this.underlineButton.checked, + isUnderline, + `${message}: Underline button should be ${isUnderline ? "" : "un"}checked` + ); + } +} diff --git a/comm/mail/test/browser/shared-modules/ContentTabHelpers.jsm b/comm/mail/test/browser/shared-modules/ContentTabHelpers.jsm new file mode 100644 index 0000000000..3d7ba3ee2c --- /dev/null +++ b/comm/mail/test/browser/shared-modules/ContentTabHelpers.jsm @@ -0,0 +1,423 @@ +/* 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 EXPORTED_SYMBOLS = [ + "open_content_tab_with_url", + "open_content_tab_with_click", + "plan_for_content_tab_load", + "wait_for_content_tab_load", + "assert_content_tab_has_favicon", + "content_tab_e", + "get_content_tab_element_display", + "assert_content_tab_element_hidden", + "assert_content_tab_element_visible", + "wait_for_content_tab_element_display", + "get_element_by_text", + "assert_content_tab_text_present", + "assert_content_tab_text_absent", + "NotificationWatcher", + "get_notification_bar_for_tab", + "updateBlocklist", + "setAndUpdateBlocklist", + "resetBlocklist", + "gMockExtProtSvcReg", + "gMockExtProtSvc", +]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +var folderDisplayHelper = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var { MockObjectReplacer } = ChromeUtils.import( + "resource://testing-common/mozmill/MockObjectHelpers.jsm" +); +var wh = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); + +var FAST_TIMEOUT = 1000; +var FAST_INTERVAL = 100; +var EXT_PROTOCOL_SVC_CID = "@mozilla.org/uriloader/external-protocol-service;1"; + +var mc = folderDisplayHelper.mc; + +var _originalBlocklistURL = null; + +var gMockExtProtSvcReg = new MockObjectReplacer( + EXT_PROTOCOL_SVC_CID, + MockExtProtConstructor +); + +/** + * gMockExtProtocolSvc allows us to capture (most if not all) attempts to + * open links in the default browser. + */ +var gMockExtProtSvc = { + _loadedURLs: [], + QueryInterface: ChromeUtils.generateQI(["nsIExternalProtocolService"]), + + externalProtocolHandlerExists(aProtocolScheme) {}, + + getApplicationDescription(aScheme) {}, + + getProtocolHandlerInfo(aProtocolScheme) {}, + + getProtocolHandlerInfoFromOS(aProtocolScheme, aFound) {}, + + isExposedProtocol(aProtocolScheme) {}, + + loadURI(aURI, aWindowContext) { + this._loadedURLs.push(aURI.spec); + }, + + setProtocolHandlerDefaults(aHandlerInfo, aOSHandlerExists) {}, + + urlLoaded(aURL) { + return this._loadedURLs.includes(aURL); + }, +}; + +function MockExtProtConstructor() { + return gMockExtProtSvc; +} + +/* Allows for planning / capture of notification events within + * content tabs, for example: plugin crash notifications, theme + * install notifications. + */ +var ALERT_TIMEOUT = 10000; + +var NotificationWatcher = { + planForNotification(aController) { + this.alerted = false; + aController.window.document.addEventListener( + "AlertActive", + this.alertActive + ); + }, + waitForNotification(aController) { + if (!this.alerted) { + utils.waitFor( + () => this.alerted, + "Timeout waiting for alert", + ALERT_TIMEOUT, + 100 + ); + } + // Double check the notification box has finished animating. + let notificationBox = mc.window.document + .getElementById("tabmail") + .selectedTab.panel.querySelector("notificationbox"); + if (notificationBox && notificationBox._animating) { + utils.waitFor( + () => !notificationBox._animating, + "Timeout waiting for notification box animation to finish", + ALERT_TIMEOUT, + 100 + ); + } + + aController.window.document.removeEventListener( + "AlertActive", + this.alertActive + ); + }, + alerted: false, + alertActive() { + NotificationWatcher.alerted = true; + }, +}; + +/** + * Opens a content tab with the given URL. + * + * @param {string} aURL - The URL to load. + * @param {string} [aLinkHandler=null] - See specialTabs.contentTabType.openTab. + * @param {boolean} [aBackground=false] Whether the tab is opened in the background. + * + * @returns {object} The newly-opened tab. + */ +function open_content_tab_with_url( + aURL, + aLinkHandler = null, + aBackground = false +) { + let tabmail = mc.window.document.getElementById("tabmail"); + let preCount = tabmail.tabContainer.allTabs.length; + tabmail.openTab("contentTab", { + url: aURL, + background: aBackground, + linkHandler: aLinkHandler, + }); + utils.waitFor( + () => tabmail.tabContainer.allTabs.length == preCount + 1, + "Timeout waiting for the content tab to open with URL: " + aURL, + FAST_TIMEOUT, + FAST_INTERVAL + ); + + // We append new tabs at the end, so check the last one. + let expectedNewTab = tabmail.tabInfo[preCount]; + folderDisplayHelper.assert_selected_tab(expectedNewTab); + wait_for_content_tab_load(expectedNewTab, aURL); + return expectedNewTab; +} + +/** + * Opens a content tab with a click on the given element. The tab is expected to + * be opened in the foreground. The element is expected to be associated with + * the given controller. + * + * @param aElem The element to click or a function that causes the tab to open. + * @param aExpectedURL The URL that is expected to be opened (string). + * @param [aController] The controller the element is associated with. Defaults + * to |mc|. + * @param [aTabType] Optional tab type to expect (string). + * @returns The newly-opened tab. + */ +function open_content_tab_with_click( + aElem, + aExpectedURL, + aController, + aTabType = "contentTab" +) { + if (aController === undefined) { + aController = mc; + } + + let preCount = + aController.window.document.getElementById("tabmail").tabContainer.allTabs + .length; + if (typeof aElem != "function") { + EventUtils.synthesizeMouseAtCenter(aElem, {}, aElem.ownerGlobal); + } else { + aElem(); + } + + utils.waitFor( + () => + aController.window.document.getElementById("tabmail").tabContainer.allTabs + .length == + preCount + 1, + "Timeout waiting for the content tab to open", + FAST_TIMEOUT, + FAST_INTERVAL + ); + + // We append new tabs at the end, so check the last one. + let expectedNewTab = + aController.window.document.getElementById("tabmail").tabInfo[preCount]; + folderDisplayHelper.assert_selected_tab(expectedNewTab); + folderDisplayHelper.assert_tab_mode_name(expectedNewTab, aTabType); + wait_for_content_tab_load(expectedNewTab, aExpectedURL); + return expectedNewTab; +} + +/** + * Call this before triggering a page load that you are going to wait for using + * |wait_for_content_tab_load|. This ensures that if a page is already displayed + * in the given tab that state is sufficiently cleaned up so it doesn't trick us + * into thinking that there is no need to wait. + * + * @param [aTab] optional tab, defaulting to the current tab. + */ +function plan_for_content_tab_load(aTab) { + if (aTab === undefined) { + aTab = mc.window.document.getElementById("tabmail").currentTabInfo; + } + aTab.pageLoaded = false; +} + +/** + * Waits for the given content tab to load completely with the given URL. This + * is expected to be accompanied by a |plan_for_content_tab_load| right before + * the action triggering the page load takes place. + * + * Note that you cannot call |plan_for_content_tab_load| if you're opening a new + * tab. That is fine, because pageLoaded is initially false. + * + * @param [aTab] Optional tab, defaulting to the current tab. + * @param aURL The URL being loaded in the tab. + * @param [aTimeout] Optional time to wait for the load. + */ +function wait_for_content_tab_load(aTab, aURL, aTimeout) { + if (aTab === undefined) { + aTab = mc.window.document.getElementById("tabmail").currentTabInfo; + } + + function isLoadedChecker() { + // Require that the progress listener think that the page is loaded. + if (!aTab.pageLoaded) { + return false; + } + // Also require that our tab infrastructure thinks that the page is loaded. + return !aTab.busy; + } + + utils.waitFor( + isLoadedChecker, + "Timeout waiting for the content tab page to load.", + aTimeout + ); + // The above may return immediately, meaning the event queue might not get a + // chance. Give it a chance now. + utils.sleep(0); + // Finally, require that the tab's browser thinks that no page is being loaded. + wh.wait_for_browser_load(aTab.browser, aURL); +} + +/** + * Gets the element with the given ID from the content tab's displayed page. + */ +function content_tab_e(aTab, aId) { + return aTab.browser.contentDocument.getElementById(aId); +} + +/** + * Assert that the given content tab has the given URL loaded as a favicon. + */ +function assert_content_tab_has_favicon(aTab, aURL) { + Assert.equal(aTab.favIconUrl, aURL, "Checking tab favicon"); +} + +/** + * Returns the current "display" style property of an element. + */ +function get_content_tab_element_display(aTab, aElem) { + let style = aTab.browser.contentWindow.getComputedStyle(aElem); + return style.getPropertyValue("display"); +} + +/** + * Asserts that the given element is hidden from view on the page. + */ +function assert_content_tab_element_hidden(aTab, aElem) { + let display = get_content_tab_element_display(aTab, aElem); + Assert.equal(display, "none", "Element should be hidden"); +} + +/** + * Asserts that the given element is visible on the page. + */ +function assert_content_tab_element_visible(aTab, aElem) { + let display = get_content_tab_element_display(aTab, aElem); + Assert.notEqual(display, "none", "Element should be visible"); +} + +/** + * Waits for the element's display property indicate it is visible. + */ +function wait_for_content_tab_element_display(aTab, aElem) { + function isValue() { + return get_content_tab_element_display(aTab, aElem) != "none"; + } + try { + utils.waitFor(isValue); + } catch (e) { + if (e instanceof utils.TimeoutError) { + Assert.report( + true, + undefined, + undefined, + "Timeout waiting for element to become visible" + ); + } else { + throw e; + } + } +} + +/** + * Finds element in document fragment, containing only the specified text + * as its textContent value. + * + * @param aRootNode Root node of the node tree where search should start. + * @param aText The string to search. + */ +function get_element_by_text(aRootNode, aText) { + // Check every node existing. + let nodes = aRootNode.querySelectorAll("*"); + for (let node of nodes) { + // We ignore surrounding whitespace. + if (node.textContent.trim() == aText) { + return node; + } + } + + return null; +} + +/** + * Finds element containing only the specified text in the content tab's page. + */ +function get_content_tab_element_by_text(aTab, aText) { + let doc = aTab.browser.contentDocument.documentElement; + return get_element_by_text(doc, aText); +} + +/** + * Asserts that the given text is present on the content tab's page. + */ +function assert_content_tab_text_present(aTab, aText) { + Assert.ok( + get_content_tab_element_by_text(aTab, aText), + `String "${aText}" should be on the content tab's page` + ); +} + +/** + * Asserts that the given text is absent on the content tab's page. + */ +function assert_content_tab_text_absent(aTab, aText) { + Assert.ok( + !get_content_tab_element_by_text(aTab, aText), + `String "${aText}" should not be on the content tab's page` + ); +} + +/** + * Returns the notification bar for a tab if one is currently visible, + * null if otherwise. + */ +function get_notification_bar_for_tab(aTab) { + let notificationBoxEls = mc.window.document + .getElementById("tabmail") + .selectedTab.panel.querySelector("notificationbox"); + if (!notificationBoxEls) { + return null; + } + + return notificationBoxEls; +} + +function updateBlocklist(aController, aCallback) { + let observer = function () { + Services.obs.removeObserver(observer, "blocklist-updated"); + aController.window.setTimeout(aCallback, 0); + }; + Services.obs.addObserver(observer, "blocklist-updated"); + Services.blocklist.QueryInterface(Ci.nsITimerCallback).notify(null); +} + +function setAndUpdateBlocklist(aController, aURL, aCallback) { + if (!_originalBlocklistURL) { + _originalBlocklistURL = Services.prefs.getCharPref( + "extensions.blocklist.url" + ); + } + Services.prefs.setCharPref("extensions.blocklist.url", aURL); + updateBlocklist(aController, aCallback); +} + +function resetBlocklist(aController, aCallback) { + Services.prefs.setCharPref("extensions.blocklist.url", _originalBlocklistURL); + updateBlocklist(aController, aCallback); +} diff --git a/comm/mail/test/browser/shared-modules/CustomizationHelpers.jsm b/comm/mail/test/browser/shared-modules/CustomizationHelpers.jsm new file mode 100644 index 0000000000..01adbb0cda --- /dev/null +++ b/comm/mail/test/browser/shared-modules/CustomizationHelpers.jsm @@ -0,0 +1,121 @@ +/* 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 EXPORTED_SYMBOLS = ["CustomizeDialogHelper"]; + +var wh = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +var USE_SHEET_PREF = "toolbar.customization.usesheet"; + +/** + * Initialize the help for a customization dialog + * + * @param {} aToolbarId + * the ID of the toolbar to be customized + * @param {} aOpenElementId + * the ID of the element to be clicked on to open the dialog + * @param {} aWindowType + * the windowType of the window containing the dialog to be opened + */ +function CustomizeDialogHelper(aToolbarId, aOpenElementId, aWindowType) { + this._toolbarId = aToolbarId; + this._openElementId = aOpenElementId; + this._windowType = aWindowType; + this._openInWindow = !Services.prefs.getBoolPref(USE_SHEET_PREF); +} + +CustomizeDialogHelper.prototype = { + /** + * Open a customization dialog by clicking on a given element. + * + * @param {} aController + * the controller object of the window for which the customization + * dialog should be opened + * @returns a controller for the customization dialog + */ + async open(aController) { + aController.window.document.getElementById(this._openElementId).click(); + + let ctc; + // Depending on preferences the customization dialog is + // either a normal window or embedded into a sheet. + if (!this._openInWindow) { + ctc = wh.wait_for_frame_load( + aController.window.document.getElementById( + "customizeToolbarSheetIFrame" + ), + "chrome://messenger/content/customizeToolbar.xhtml" + ); + } else { + ctc = wh.wait_for_existing_window(this._windowType); + } + utils.sleep(500); + return ctc; + }, + + /** + * Close the customization dialog. + * + * @param {} aCtc + * the controller object of the customization dialog which should be closed + */ + close(aCtc) { + if (this._openInWindow) { + wh.plan_for_window_close(aCtc); + } + + let doneButton = aCtc.window.document.getElementById("donebutton"); + EventUtils.synthesizeMouseAtCenter(doneButton, {}, doneButton.ownerGlobal); + utils.sleep(0); + // XXX There should be an equivalent for testing the closure of + // XXX the dialog embedded in a sheet, but I do not know how. + if (this._openInWindow) { + wh.wait_for_window_close(); + Assert.ok(aCtc.window.closed, "The customization dialog is not closed."); + } + }, + + /** + * Restore the default buttons in the header pane toolbar + * by clicking the corresponding button in the palette dialog + * and check if it worked. + * + * @param {} aController + * the controller object of the window for which the customization + * dialog should be opened + */ + async restoreDefaultButtons(aController) { + let ctc = await this.open(aController); + let restoreButton = ctc.window.document + .getElementById("main-box") + .querySelector("[oncommand*='overlayRestoreDefaultSet();']"); + + EventUtils.synthesizeMouseAtCenter( + restoreButton, + {}, + restoreButton.ownerGlobal + ); + utils.sleep(0); + + this.close(ctc); + + let toolbar = aController.window.document.getElementById(this._toolbarId); + let defaultSet = toolbar.getAttribute("defaultset"); + + Assert.equal(toolbar.currentSet, defaultSet); + }, +}; diff --git a/comm/mail/test/browser/shared-modules/DOMHelpers.jsm b/comm/mail/test/browser/shared-modules/DOMHelpers.jsm new file mode 100644 index 0000000000..719de9c381 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/DOMHelpers.jsm @@ -0,0 +1,256 @@ +/* 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 EXPORTED_SYMBOLS = [ + "assert_element_visible", + "element_visible_recursive", + "assert_element_not_visible", + "wait_for_element", + "assert_next_nodes", + "assert_previous_nodes", + "wait_for_element_enabled", + "check_element_visible", + "wait_for_element_visible", + "wait_for_element_invisible", + "collapse_panes", +]; + +const lazy = {}; + +ChromeUtils.defineModuleGetter( + lazy, + "mc", + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +/** + * This function takes either a string or an elementlibs.Elem, and returns + * whether it is hidden or not (simply by poking at its hidden property). It + * doesn't try to do anything smart, like is it not into view, or whatever. + * + * @param aElt The element to query. + * @returns Whether the element is visible or not. + */ +function element_visible(aElt) { + let e; + if (typeof aElt == "string") { + e = lazy.mc.window.document.getElementById(aElt); + } else { + e = aElt; + } + return !e.hidden; +} + +/** + * Assert that en element's visible. + * + * @param aElt The element, an ID or an elementlibs.Elem + * @param aWhy The error message in case of failure + */ +function assert_element_visible(aElt, aWhy) { + Assert.ok(element_visible(aElt), aWhy); +} + +/** + * Returns if a element is visible by traversing all parent elements and check + * that all are visible. + * + * @param aElem The element to be checked + */ +function element_visible_recursive(aElem) { + if (aElem.hidden || aElem.collapsed) { + return false; + } + let parent = aElem.parentNode; + if (parent == null) { + return true; + } + + // #tabpanelcontainer and its parent #tabmail-tabbox have the same selectedPanel. + // Don't ask me why, it's just the way it is. + if ( + "selectedPanel" in parent && + parent.selectedPanel != aElem && + aElem.id != "tabpanelcontainer" + ) { + return false; + } + return element_visible_recursive(parent); +} + +/** + * Assert that en element's not visible. + * + * @param aElt The element, an ID or an elementlibs.Elem + * @param aWhy The error message in case of failure + */ +function assert_element_not_visible(aElt, aWhy) { + Assert.ok(!element_visible(aElt), aWhy); +} + +/** + * Wait for and return an element matching a particular CSS selector. + * + * @param aParent the node to begin searching from + * @param aSelector the CSS selector to search with + */ +function wait_for_element(aParent, aSelector) { + let target = null; + utils.waitFor(function () { + target = aParent.querySelector(aSelector); + return target != null; + }, "Timed out waiting for a target for selector: " + aSelector); + + return target; +} + +/** + * Given some starting node aStart, ensure that aStart and the aNum next + * siblings of aStart are nodes of type aNodeType. + * + * @param aNodeType the type of node to look for, example: "br". + * @param aStart the first node to check. + * @param aNum the number of sibling br nodes to check for. + */ +function assert_next_nodes(aNodeType, aStart, aNum) { + let node = aStart; + for (let i = 0; i < aNum; ++i) { + node = node.nextSibling; + if (node.localName != aNodeType) { + throw new Error( + "The node should be followed by " + + aNum + + " nodes of " + + "type " + + aNodeType + ); + } + } + return node; +} + +/** + * Given some starting node aStart, ensure that aStart and the aNum previous + * siblings of aStart are nodes of type aNodeType. + * + * @param aNodeType the type of node to look for, example: "br". + * @param aStart the first node to check. + * @param aNum the number of sibling br nodes to check for. + */ +function assert_previous_nodes(aNodeType, aStart, aNum) { + let node = aStart; + for (let i = 0; i < aNum; ++i) { + node = node.previousSibling; + if (node.localName != aNodeType) { + throw new Error( + "The node should be preceded by " + + aNum + + " nodes of " + + "type " + + aNodeType + ); + } + } + return node; +} + +/** + * Given some element, wait for that element to be enabled or disabled, + * depending on the value of aEnabled. + * + * @param aController the controller parent of the element + * @param aNode the element to check. + * @param aEnabled whether or not the node should be enabled, or disabled. + */ +function wait_for_element_enabled(aController, aElement, aEnabled) { + if (!("disabled" in aElement)) { + throw new Error( + "Element does not appear to have disabled property; id=" + aElement.id + ); + } + + utils.waitFor( + () => aElement.disabled != aEnabled, + "Element should have eventually been " + + (aEnabled ? "enabled" : "disabled") + + "; id=" + + aElement.id + ); +} + +function check_element_visible(aController, aId) { + let element = aController.window.document.getElementById(aId); + if (!element) { + return false; + } + + while (element) { + if ( + element.hidden || + element.collapsed || + element.clientWidth == 0 || + element.clientHeight == 0 || + aController.window.getComputedStyle(element).display == "none" + ) { + return false; + } + element = element.parentElement; + } + return true; +} + +/** + * Wait for a particular element to become fully visible. + * + * @param aController the controller parent of the element + * @param aId id of the element to wait for + */ +function wait_for_element_visible(aController, aId) { + utils.waitFor(function () { + return check_element_visible(aController, aId); + }, "Timed out waiting for element with ID=" + aId + " to become visible"); +} + +/** + * Wait for a particular element to become fully invisible. + * + * @param aController the controller parent of the element + * @param aId id of the element to wait for + */ +function wait_for_element_invisible(aController, aId) { + utils.waitFor(function () { + return !check_element_visible(aController, aId); + }, "Timed out waiting for element with ID=" + aId + " to become invisible"); +} + +/** + * Helper to collapse panes separated by splitters. If aElement is a splitter + * itself, then this splitter is collapsed, otherwise all splitters that are + * direct children of aElement are collapsed. + * + * @param aElement The splitter or container + * @param aShouldBeCollapsed If true, collapse the pane + */ +function collapse_panes(aElement, aShouldBeCollapsed) { + let state = aShouldBeCollapsed ? "collapsed" : "open"; + if (aElement.localName == "splitter") { + aElement.setAttribute("state", state); + } else { + for (let n of aElement.childNodes) { + if (n.localName == "splitter") { + n.setAttribute("state", state); + } + } + } + // Spin the event loop once to let other window elements redraw. + utils.sleep(50); +} diff --git a/comm/mail/test/browser/shared-modules/EventUtils.jsm b/comm/mail/test/browser/shared-modules/EventUtils.jsm new file mode 100644 index 0000000000..ad21f1b670 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/EventUtils.jsm @@ -0,0 +1,876 @@ +// Export all available functions for Mozmill +var EXPORTED_SYMBOLS = [ + "sendChar", + "sendString", + "synthesizeMouse", + "synthesizeMouseAtCenter", + "synthesizeMouseScroll", + "synthesizeKey", + "synthesizeMouseExpectEvent", +]; + +function computeButton(aEvent) { + if (typeof aEvent.button != "undefined") { + return aEvent.button; + } + return aEvent.type == "contextmenu" ? 2 : 0; +} + +function computeButtons(aEvent, utils) { + if (typeof aEvent.buttons != "undefined") { + return aEvent.buttons; + } + + if (typeof aEvent.button != "undefined") { + return utils.MOUSE_BUTTONS_NOT_SPECIFIED; + } + + if (typeof aEvent.type != "undefined" && aEvent.type != "mousedown") { + return utils.MOUSE_BUTTONS_NO_BUTTON; + } + + return utils.MOUSE_BUTTONS_NOT_SPECIFIED; +} + +/** + * Parse the key modifier flags from aEvent. Used to share code between + * synthesizeMouse and synthesizeKey. + */ +function _parseModifiers(aEvent) { + var hwindow = Services.appShell.hiddenDOMWindow; + + var mval = 0; + if (aEvent.shiftKey) { + mval |= Ci.nsIDOMWindowUtils.MODIFIER_SHIFT; + } + if (aEvent.ctrlKey) { + mval |= Ci.nsIDOMWindowUtils.MODIFIER_CONTROL; + } + if (aEvent.altKey) { + mval |= Ci.nsIDOMWindowUtils.MODIFIER_ALT; + } + if (aEvent.metaKey) { + mval |= Ci.nsIDOMWindowUtils.MODIFIER_META; + } + if (aEvent.accelKey) { + mval |= hwindow.navigator.platform.includes("Mac") + ? Ci.nsIDOMWindowUtils.MODIFIER_META + : Ci.nsIDOMWindowUtils.MODIFIER_CONTROL; + } + + return mval; +} + +/** + * Send the char aChar to the focused element. This method handles casing of + * chars (sends the right charcode, and sends a shift key for uppercase chars). + * No other modifiers are handled at this point. + * + * For now this method only works for ASCII characters and emulates the shift + * key state on US keyboard layout. + */ +function sendChar(aChar, aWindow) { + var hasShift; + // Emulate US keyboard layout for the shiftKey state. + switch (aChar) { + case "!": + case "@": + case "#": + case "$": + case "%": + case "^": + case "&": + case "*": + case "(": + case ")": + case "_": + case "+": + case "{": + case "}": + case ":": + case '"': + case "|": + case "<": + case ">": + case "?": + hasShift = true; + break; + default: + hasShift = + aChar.toLowerCase() != aChar.toUpperCase() && + aChar == aChar.toUpperCase(); + break; + } + synthesizeKey(aChar, { shiftKey: hasShift }, aWindow); +} + +/** + * Send the string aStr to the focused element. + * + * For now this method only works for ASCII characters and emulates the shift + * key state on US keyboard layout. + */ +function sendString(aStr, aWindow) { + for (var i = 0; i < aStr.length; ++i) { + sendChar(aStr.charAt(i), aWindow); + } +} + +/** + * Synthesize a mouse event on a target. The actual client point is determined + * by taking the aTarget's client box and offseting it by aOffsetX and + * aOffsetY. This allows mouse clicks to be simulated by calling this method. + * + * aEvent is an object which may contain the properties: + * `shiftKey`, `ctrlKey`, `altKey`, `metaKey`, `accessKey`, `clickCount`, + * `button`, `type`. + * For valid `type`s see nsIDOMWindowUtils' `sendMouseEvent`. + * + * If the type is specified, an mouse event of that type is fired. Otherwise, + * a mousedown followed by a mouseup is performed. + * + * aWindow is optional, and defaults to the current window object. + * + * Returns whether the event had preventDefault() called on it. + */ +function synthesizeMouse(aTarget, aOffsetX, aOffsetY, aEvent, aWindow) { + var rect = aTarget.getBoundingClientRect(); + return synthesizeMouseAtPoint( + rect.left + aOffsetX, + rect.top + aOffsetY, + aEvent, + aWindow + ); +} + +/* + * Synthesize a mouse event at a particular point in aWindow. + * + * aEvent is an object which may contain the properties: + * `shiftKey`, `ctrlKey`, `altKey`, `metaKey`, `accessKey`, `clickCount`, + * `button`, `type`. + * For valid `type`s see nsIDOMWindowUtils' `sendMouseEvent`. + * + * If the type is specified, an mouse event of that type is fired. Otherwise, + * a mousedown followed by a mouseup is performed. + * + * aWindow is optional, and defaults to the current window object. + */ +function synthesizeMouseAtPoint(left, top, aEvent, aWindow) { + var utils = aWindow.windowUtils; + var defaultPrevented = false; + + if (utils) { + var button = computeButton(aEvent); + var clickCount = aEvent.clickCount || 1; + var modifiers = _parseModifiers(aEvent, aWindow); + var pressure = "pressure" in aEvent ? aEvent.pressure : 0; + + // aWindow might be cross-origin from us. + var MouseEvent = aWindow.MouseEvent; + + // Default source to mouse. + var inputSource = + "inputSource" in aEvent + ? aEvent.inputSource + : MouseEvent.MOZ_SOURCE_MOUSE; + // Compute a pointerId if needed. + var id; + if ("id" in aEvent) { + id = aEvent.id; + } else { + var isFromPen = inputSource === MouseEvent.MOZ_SOURCE_PEN; + id = isFromPen + ? utils.DEFAULT_PEN_POINTER_ID + : utils.DEFAULT_MOUSE_POINTER_ID; + } + + var isDOMEventSynthesized = + "isSynthesized" in aEvent ? aEvent.isSynthesized : true; + var isWidgetEventSynthesized = + "isWidgetEventSynthesized" in aEvent + ? aEvent.isWidgetEventSynthesized + : false; + if ("type" in aEvent && aEvent.type) { + defaultPrevented = utils.sendMouseEvent( + aEvent.type, + left, + top, + button, + clickCount, + modifiers, + false, + pressure, + inputSource, + isDOMEventSynthesized, + isWidgetEventSynthesized, + computeButtons(aEvent, utils), + id + ); + } else { + utils.sendMouseEvent( + "mousedown", + left, + top, + button, + clickCount, + modifiers, + false, + pressure, + inputSource, + isDOMEventSynthesized, + isWidgetEventSynthesized, + computeButtons(Object.assign({ type: "mousedown" }, aEvent), utils), + id + ); + utils.sendMouseEvent( + "mouseup", + left, + top, + button, + clickCount, + modifiers, + false, + pressure, + inputSource, + isDOMEventSynthesized, + isWidgetEventSynthesized, + computeButtons(Object.assign({ type: "mouseup" }, aEvent), utils), + id + ); + } + } + + return defaultPrevented; +} + +// Call synthesizeMouse with coordinates at the center of aTarget. +function synthesizeMouseAtCenter(aTarget, aEvent, aWindow) { + var rect = aTarget.getBoundingClientRect(); + return synthesizeMouse( + aTarget, + rect.width / 2, + rect.height / 2, + aEvent, + aWindow + ); +} + +/** + * Synthesize a mouse scroll event on a target. The actual client point is determined + * by taking the aTarget's client box and offsetting it by aOffsetX and + * aOffsetY. + * + * aEvent is an object which may contain the properties: + * shiftKey, ctrlKey, altKey, metaKey, accessKey, button, type, axis, delta, hasPixels + * + * If the type is specified, a mouse scroll event of that type is fired. Otherwise, + * "DOMMouseScroll" is used. + * + * If the axis is specified, it must be one of "horizontal" or "vertical". If not specified, + * "vertical" is used. + * + * 'delta' is the amount to scroll by (can be positive or negative). It must + * be specified. + * + * 'hasPixels' specifies whether kHasPixels should be set in the scrollFlags. + * + * aWindow is optional, and defaults to the current window object. + */ +function synthesizeMouseScroll(aTarget, aOffsetX, aOffsetY, aEvent, aWindow) { + var utils = aWindow.windowUtils; + if (utils) { + // See nsMouseScrollFlags in nsGUIEvent.h + const kIsVertical = 0x02; + const kIsHorizontal = 0x04; + const kHasPixels = 0x08; + + var button = aEvent.button || 0; + var modifiers = _parseModifiers(aEvent); + + var rect = aTarget.getBoundingClientRect(); + + var left = rect.left; + var top = rect.top; + + var type = ("type" in aEvent && aEvent.type) || "DOMMouseScroll"; + var axis = aEvent.axis || "vertical"; + var scrollFlags = axis == "horizontal" ? kIsHorizontal : kIsVertical; + if (aEvent.hasPixels) { + scrollFlags |= kHasPixels; + } + utils.sendMouseScrollEvent( + type, + left + aOffsetX, + top + aOffsetY, + button, + scrollFlags, + aEvent.delta, + modifiers + ); + } +} + +/** + * Synthesize a key event. It is targeted at whatever would be targeted by an + * actual keypress by the user, typically the focused element. + * + * aKey should be: + * - key value (recommended). If you specify a non-printable key name, + * append "KEY_" prefix. Otherwise, specifying a printable key, the + * key value should be specified. + * - keyCode name starting with "VK_" (e.g., VK_RETURN). This is available + * only for compatibility with legacy API. Don't use this with new tests. + * + * aEvent is an object which may contain the properties: + * - code: If you emulates a physical keyboard's key event, this should be + * specified. + * - repeat: If you emulates auto-repeat, you should set the count of repeat. + * This method will automatically synthesize keydown (and keypress). + * - location: If you want to specify this, you can specify this explicitly. + * However, if you don't specify this value, it will be computed + * from code value. + * - type: Basically, you shouldn't specify this. Then, this function will + * synthesize keydown (, keypress) and keyup. + * If keydown is specified, this only fires keydown (and keypress if + * it should be fired). + * If keyup is specified, this only fires keyup. + * - altKey, altGraphKey, ctrlKey, capsLockKey, fnKey, fnLockKey, numLockKey, + * metaKey, osKey, scrollLockKey, shiftKey, symbolKey, symbolLockKey: + * Basically, you shouldn't use these attributes. nsITextInputProcessor + * manages modifier key state when you synthesize modifier key events. + * However, if some of these attributes are true, this function activates + * the modifiers only during dispatching the key events. + * Note that if some of these values are false, they are ignored (i.e., + * not inactivated with this function). + * - keyCode: Must be 0 - 255 (0xFF). If this is specified explicitly, + * .keyCode value is initialized with this value. + * + * aWindow is optional, and defaults to the current window object. + * aCallback is optional, use the callback for receiving notifications of TIP. + */ +function synthesizeKey(aKey, aEvent, aWindow, aCallback) { + var TIP = _getTIP(aWindow, aCallback); + if (!TIP) { + return; + } + var KeyboardEvent = _getKeyboardEvent(aWindow); + var modifiers = _emulateToActivateModifiers(TIP, aEvent, aWindow); + var keyEventDict = _createKeyboardEventDictionary(aKey, aEvent, aWindow); + var keyEvent = new KeyboardEvent("", keyEventDict.dictionary); + var dispatchKeydown = + !("type" in aEvent) || aEvent.type === "keydown" || !aEvent.type; + var dispatchKeyup = + !("type" in aEvent) || aEvent.type === "keyup" || !aEvent.type; + + try { + if (dispatchKeydown) { + TIP.keydown(keyEvent, keyEventDict.flags); + if ("repeat" in aEvent && aEvent.repeat > 1) { + keyEventDict.dictionary.repeat = true; + var repeatedKeyEvent = new KeyboardEvent("", keyEventDict.dictionary); + for (var i = 1; i < aEvent.repeat; i++) { + TIP.keydown(repeatedKeyEvent, keyEventDict.flags); + } + } + } + if (dispatchKeyup) { + TIP.keyup(keyEvent, keyEventDict.flags); + } + } finally { + _emulateToInactivateModifiers(TIP, modifiers, aWindow); + } +} + +var _gSeenEvent = false; + +/** + * Indicate that an event with an original target of aExpectedTarget and + * a type of aExpectedEvent is expected to be fired, or not expected to + * be fired. + */ +function _expectEvent(aExpectedTarget, aExpectedEvent, aTestName) { + if (!aExpectedTarget || !aExpectedEvent) { + return null; + } + + _gSeenEvent = false; + + var type = + aExpectedEvent.charAt(0) == "!" + ? aExpectedEvent.substring(1) + : aExpectedEvent; + var eventHandler = function (event) { + var epassed = + !_gSeenEvent && event.target == aExpectedTarget && event.type == type; + if (!epassed) { + throw new Error( + aTestName + " " + type + " event target " + (_gSeenEvent ? "twice" : "") + ); + } + _gSeenEvent = true; + }; + + aExpectedTarget.addEventListener(type, eventHandler); + return eventHandler; +} + +/** + * Check if the event was fired or not. The event handler aEventHandler + * will be removed. + */ +function _checkExpectedEvent( + aExpectedTarget, + aExpectedEvent, + aEventHandler, + aTestName +) { + if (aEventHandler) { + var expectEvent = aExpectedEvent.charAt(0) != "!"; + var type = expectEvent ? aExpectedEvent : aExpectedEvent.substring(1); + aExpectedTarget.removeEventListener(type, aEventHandler); + var desc = type + " event"; + if (expectEvent) { + desc += " not"; + } + if (_gSeenEvent != expectEvent) { + throw new Error(aTestName + ": " + desc + " fired."); + } + } + + _gSeenEvent = false; +} + +/** + * Similar to synthesizeMouse except that a test is performed to see if an + * event is fired at the right target as a result. + * + * aExpectedTarget - the expected originalTarget of the event. + * aExpectedEvent - the expected type of the event, such as 'select'. + * aTestName - the test name when outputting results + * + * To test that an event is not fired, use an expected type preceded by an + * exclamation mark, such as '!select'. This might be used to test that a + * click on a disabled element doesn't fire certain events for instance. + * + * aWindow is optional, and defaults to the current window object. + */ +function synthesizeMouseExpectEvent( + aTarget, + aOffsetX, + aOffsetY, + aEvent, + aExpectedTarget, + aExpectedEvent, + aTestName, + aWindow +) { + var eventHandler = _expectEvent(aExpectedTarget, aExpectedEvent, aTestName); + synthesizeMouse(aTarget, aOffsetX, aOffsetY, aEvent, aWindow); + _checkExpectedEvent(aExpectedTarget, aExpectedEvent, eventHandler, aTestName); +} + +/** + * The functions that follow were copied from + * mozilla-central/testing/mochitest/tests/SimpleTest/EventUtils.js + */ + +var TIPMap = new WeakMap(); + +function _getTIP(aWindow, aCallback) { + var tip; + if (TIPMap.has(aWindow)) { + tip = TIPMap.get(aWindow); + } else { + tip = Cc["@mozilla.org/text-input-processor;1"].createInstance( + Ci.nsITextInputProcessor + ); + TIPMap.set(aWindow, tip); + } + if (!tip.beginInputTransactionForTests(aWindow, aCallback)) { + tip = null; + TIPMap.delete(aWindow); + } + return tip; +} + +function _getKeyboardEvent(aWindow) { + if (typeof KeyboardEvent != "undefined") { + try { + // See if the object can be instantiated; sometimes this yields + // 'TypeError: can't access dead object' or 'KeyboardEvent is not a constructor'. + new KeyboardEvent("", {}); + return KeyboardEvent; + } catch (ex) {} + } + return aWindow.KeyboardEvent; +} + +/* eslint-disable complexity */ +function _guessKeyNameFromKeyCode(aKeyCode, aWindow) { + var KeyboardEvent = _getKeyboardEvent(aWindow); + switch (aKeyCode) { + case KeyboardEvent.DOM_VK_CANCEL: + return "Cancel"; + case KeyboardEvent.DOM_VK_HELP: + return "Help"; + case KeyboardEvent.DOM_VK_BACK_SPACE: + return "Backspace"; + case KeyboardEvent.DOM_VK_TAB: + return "Tab"; + case KeyboardEvent.DOM_VK_CLEAR: + return "Clear"; + case KeyboardEvent.DOM_VK_RETURN: + return "Enter"; + case KeyboardEvent.DOM_VK_SHIFT: + return "Shift"; + case KeyboardEvent.DOM_VK_CONTROL: + return "Control"; + case KeyboardEvent.DOM_VK_ALT: + return "Alt"; + case KeyboardEvent.DOM_VK_PAUSE: + return "Pause"; + case KeyboardEvent.DOM_VK_EISU: + return "Eisu"; + case KeyboardEvent.DOM_VK_ESCAPE: + return "Escape"; + case KeyboardEvent.DOM_VK_CONVERT: + return "Convert"; + case KeyboardEvent.DOM_VK_NONCONVERT: + return "NonConvert"; + case KeyboardEvent.DOM_VK_ACCEPT: + return "Accept"; + case KeyboardEvent.DOM_VK_MODECHANGE: + return "ModeChange"; + case KeyboardEvent.DOM_VK_PAGE_UP: + return "PageUp"; + case KeyboardEvent.DOM_VK_PAGE_DOWN: + return "PageDown"; + case KeyboardEvent.DOM_VK_END: + return "End"; + case KeyboardEvent.DOM_VK_HOME: + return "Home"; + case KeyboardEvent.DOM_VK_LEFT: + return "ArrowLeft"; + case KeyboardEvent.DOM_VK_UP: + return "ArrowUp"; + case KeyboardEvent.DOM_VK_RIGHT: + return "ArrowRight"; + case KeyboardEvent.DOM_VK_DOWN: + return "ArrowDown"; + case KeyboardEvent.DOM_VK_SELECT: + return "Select"; + case KeyboardEvent.DOM_VK_PRINT: + return "Print"; + case KeyboardEvent.DOM_VK_EXECUTE: + return "Execute"; + case KeyboardEvent.DOM_VK_PRINTSCREEN: + return "PrintScreen"; + case KeyboardEvent.DOM_VK_INSERT: + return "Insert"; + case KeyboardEvent.DOM_VK_DELETE: + return "Delete"; + case KeyboardEvent.DOM_VK_WIN: + return "OS"; + case KeyboardEvent.DOM_VK_CONTEXT_MENU: + return "ContextMenu"; + case KeyboardEvent.DOM_VK_SLEEP: + return "Standby"; + case KeyboardEvent.DOM_VK_F1: + return "F1"; + case KeyboardEvent.DOM_VK_F2: + return "F2"; + case KeyboardEvent.DOM_VK_F3: + return "F3"; + case KeyboardEvent.DOM_VK_F4: + return "F4"; + case KeyboardEvent.DOM_VK_F5: + return "F5"; + case KeyboardEvent.DOM_VK_F6: + return "F6"; + case KeyboardEvent.DOM_VK_F7: + return "F7"; + case KeyboardEvent.DOM_VK_F8: + return "F8"; + case KeyboardEvent.DOM_VK_F9: + return "F9"; + case KeyboardEvent.DOM_VK_F10: + return "F10"; + case KeyboardEvent.DOM_VK_F11: + return "F11"; + case KeyboardEvent.DOM_VK_F12: + return "F12"; + case KeyboardEvent.DOM_VK_F13: + return "F13"; + case KeyboardEvent.DOM_VK_F14: + return "F14"; + case KeyboardEvent.DOM_VK_F15: + return "F15"; + case KeyboardEvent.DOM_VK_F16: + return "F16"; + case KeyboardEvent.DOM_VK_F17: + return "F17"; + case KeyboardEvent.DOM_VK_F18: + return "F18"; + case KeyboardEvent.DOM_VK_F19: + return "F19"; + case KeyboardEvent.DOM_VK_F20: + return "F20"; + case KeyboardEvent.DOM_VK_F21: + return "F21"; + case KeyboardEvent.DOM_VK_F22: + return "F22"; + case KeyboardEvent.DOM_VK_F23: + return "F23"; + case KeyboardEvent.DOM_VK_F24: + return "F24"; + case KeyboardEvent.DOM_VK_NUM_LOCK: + return "NumLock"; + case KeyboardEvent.DOM_VK_SCROLL_LOCK: + return "ScrollLock"; + case KeyboardEvent.DOM_VK_VOLUME_MUTE: + return "AudioVolumeMute"; + case KeyboardEvent.DOM_VK_VOLUME_DOWN: + return "AudioVolumeDown"; + case KeyboardEvent.DOM_VK_VOLUME_UP: + return "AudioVolumeUp"; + case KeyboardEvent.DOM_VK_META: + return "Meta"; + case KeyboardEvent.DOM_VK_ALTGR: + return "AltGraph"; + case KeyboardEvent.DOM_VK_ATTN: + return "Attn"; + case KeyboardEvent.DOM_VK_CRSEL: + return "CrSel"; + case KeyboardEvent.DOM_VK_EXSEL: + return "ExSel"; + case KeyboardEvent.DOM_VK_EREOF: + return "EraseEof"; + case KeyboardEvent.DOM_VK_PLAY: + return "Play"; + default: + return "Unidentified"; + } +} +/* eslint-enable complexity */ + +function _createKeyboardEventDictionary(aKey, aKeyEvent, aWindow) { + var result = { dictionary: null, flags: 0 }; + var keyCodeIsDefined = "keyCode" in aKeyEvent; + var keyCode = + keyCodeIsDefined && aKeyEvent.keyCode >= 0 && aKeyEvent.keyCode <= 255 + ? aKeyEvent.keyCode + : 0; + var keyName = "Unidentified"; + if (aKey.indexOf("KEY_") == 0) { + keyName = aKey.substr("KEY_".length); + result.flags |= Ci.nsITextInputProcessor.KEY_NON_PRINTABLE_KEY; + } else if (aKey.indexOf("VK_") == 0) { + keyCode = _getKeyboardEvent(aWindow)["DOM_" + aKey]; + if (!keyCode) { + throw new Error("Unknown key: " + aKey); + } + keyName = _guessKeyNameFromKeyCode(keyCode, aWindow); + result.flags |= Ci.nsITextInputProcessor.KEY_NON_PRINTABLE_KEY; + } else if (aKey != "") { + keyName = aKey; + if (!keyCodeIsDefined) { + keyCode = _computeKeyCodeFromChar(aKey.charAt(0), aWindow); + } + if (!keyCode) { + result.flags |= Ci.nsITextInputProcessor.KEY_KEEP_KEYCODE_ZERO; + } + result.flags |= Ci.nsITextInputProcessor.KEY_FORCE_PRINTABLE_KEY; + } + var locationIsDefined = "location" in aKeyEvent; + if (locationIsDefined && aKeyEvent.location === 0) { + result.flags |= Ci.nsITextInputProcessor.KEY_KEEP_KEY_LOCATION_STANDARD; + } + result.dictionary = { + key: keyName, + code: "code" in aKeyEvent ? aKeyEvent.code : "", + location: locationIsDefined ? aKeyEvent.location : 0, + repeat: "repeat" in aKeyEvent ? aKeyEvent.repeat === true : false, + keyCode, + }; + return result; +} + +function _emulateToActivateModifiers(aTIP, aKeyEvent, aWindow) { + if (!aKeyEvent) { + return null; + } + var KeyboardEvent = _getKeyboardEvent(aWindow); + + var modifiers = { + normal: [ + { key: "Alt", attr: "altKey" }, + { key: "AltGraph", attr: "altGraphKey" }, + { key: "Control", attr: "ctrlKey" }, + { key: "Fn", attr: "fnKey" }, + { key: "Meta", attr: "metaKey" }, + { key: "OS", attr: "osKey" }, + { key: "Shift", attr: "shiftKey" }, + { key: "Symbol", attr: "symbolKey" }, + { + key: aWindow.navigator.platform.includes("Mac") ? "Meta" : "Control", + attr: "accelKey", + }, + ], + lockable: [ + { key: "CapsLock", attr: "capsLockKey" }, + { key: "FnLock", attr: "fnLockKey" }, + { key: "NumLock", attr: "numLockKey" }, + { key: "ScrollLock", attr: "scrollLockKey" }, + { key: "SymbolLock", attr: "symbolLockKey" }, + ], + }; + + for (let i = 0; i < modifiers.normal.length; i++) { + if (!aKeyEvent[modifiers.normal[i].attr]) { + continue; + } + if (aTIP.getModifierState(modifiers.normal[i].key)) { + continue; // already activated. + } + let event = new KeyboardEvent("", { key: modifiers.normal[i].key }); + aTIP.keydown( + event, + aTIP.KEY_NON_PRINTABLE_KEY | aTIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT + ); + modifiers.normal[i].activated = true; + } + for (let i = 0; i < modifiers.lockable.length; i++) { + if (!aKeyEvent[modifiers.lockable[i].attr]) { + continue; + } + if (aTIP.getModifierState(modifiers.lockable[i].key)) { + continue; // already activated. + } + let event = new KeyboardEvent("", { key: modifiers.lockable[i].key }); + aTIP.keydown( + event, + aTIP.KEY_NON_PRINTABLE_KEY | aTIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT + ); + aTIP.keyup( + event, + aTIP.KEY_NON_PRINTABLE_KEY | aTIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT + ); + modifiers.lockable[i].activated = true; + } + return modifiers; +} + +function _emulateToInactivateModifiers(aTIP, aModifiers, aWindow) { + if (!aModifiers) { + return; + } + var KeyboardEvent = _getKeyboardEvent(aWindow); + for (let i = 0; i < aModifiers.normal.length; i++) { + if (!aModifiers.normal[i].activated) { + continue; + } + let event = new KeyboardEvent("", { key: aModifiers.normal[i].key }); + aTIP.keyup( + event, + aTIP.KEY_NON_PRINTABLE_KEY | aTIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT + ); + } + for (let i = 0; i < aModifiers.lockable.length; i++) { + if (!aModifiers.lockable[i].activated) { + continue; + } + if (!aTIP.getModifierState(aModifiers.lockable[i].key)) { + continue; // who already inactivated this? + } + let event = new KeyboardEvent("", { key: aModifiers.lockable[i].key }); + aTIP.keydown( + event, + aTIP.KEY_NON_PRINTABLE_KEY | aTIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT + ); + aTIP.keyup( + event, + aTIP.KEY_NON_PRINTABLE_KEY | aTIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT + ); + } +} + +/* eslint-disable complexity */ +function _computeKeyCodeFromChar(aChar, aWindow) { + if (aChar.length != 1) { + return 0; + } + var KeyEvent = _getKeyboardEvent(aWindow); + if (aChar >= "a" && aChar <= "z") { + return KeyEvent.DOM_VK_A + aChar.charCodeAt(0) - "a".charCodeAt(0); + } + if (aChar >= "A" && aChar <= "Z") { + return KeyEvent.DOM_VK_A + aChar.charCodeAt(0) - "A".charCodeAt(0); + } + if (aChar >= "0" && aChar <= "9") { + return KeyEvent.DOM_VK_0 + aChar.charCodeAt(0) - "0".charCodeAt(0); + } + // returns US keyboard layout's keycode + switch (aChar) { + case "~": + case "`": + return KeyEvent.DOM_VK_BACK_QUOTE; + case "!": + return KeyEvent.DOM_VK_1; + case "@": + return KeyEvent.DOM_VK_2; + case "#": + return KeyEvent.DOM_VK_3; + case "$": + return KeyEvent.DOM_VK_4; + case "%": + return KeyEvent.DOM_VK_5; + case "^": + return KeyEvent.DOM_VK_6; + case "&": + return KeyEvent.DOM_VK_7; + case "*": + return KeyEvent.DOM_VK_8; + case "(": + return KeyEvent.DOM_VK_9; + case ")": + return KeyEvent.DOM_VK_0; + case "-": + case "_": + return KeyEvent.DOM_VK_SUBTRACT; + case "+": + case "=": + return KeyEvent.DOM_VK_EQUALS; + case "{": + case "[": + return KeyEvent.DOM_VK_OPEN_BRACKET; + case "}": + case "]": + return KeyEvent.DOM_VK_CLOSE_BRACKET; + case "|": + case "\\": + return KeyEvent.DOM_VK_BACK_SLASH; + case ":": + case ";": + return KeyEvent.DOM_VK_SEMICOLON; + case "'": + case '"': + return KeyEvent.DOM_VK_QUOTE; + case "<": + case ",": + return KeyEvent.DOM_VK_COMMA; + case ">": + case ".": + return KeyEvent.DOM_VK_PERIOD; + case "?": + case "/": + return KeyEvent.DOM_VK_SLASH; + case "\n": + return KeyEvent.DOM_VK_RETURN; + case " ": + return KeyEvent.DOM_VK_SPACE; + default: + return 0; + } +} +/* eslint-enable complexity */ diff --git a/comm/mail/test/browser/shared-modules/FolderDisplayHelpers.jsm b/comm/mail/test/browser/shared-modules/FolderDisplayHelpers.jsm new file mode 100644 index 0000000000..a90cbcf457 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/FolderDisplayHelpers.jsm @@ -0,0 +1,3243 @@ +/* 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 EXPORTED_SYMBOLS = [ + "add_message_to_folder", + "add_message_sets_to_folders", + "add_to_toolbar", + "archive_messages", + "archive_selected_messages", + "assert_attachment_list_focused", + "assert_collapsed", + "assert_default_window_size", + "assert_displayed", + "assert_expanded", + "assert_folder_at_index_as", + "assert_folder_child_in_view", + "assert_folder_collapsed", + "assert_folder_displayed", + "assert_folder_expanded", + "assert_folder_mode", + "assert_folder_not_visible", + "assert_folder_selected", + "assert_folder_selected_and_displayed", + "assert_folder_tree_focused", + "assert_folder_tree_view_row_count", + "assert_folder_visible", + "assert_folders_selected", + "assert_folders_selected_and_displayed", + "assert_mail_view", + "assert_message_not_in_view", + "assert_message_pane_focused", + "assert_message_pane_hidden", + "assert_message_pane_visible", + "assert_messages_in_view", + "assert_messages_not_in_view", + "assert_messages_summarized", + "assert_multimessage_pane_focused", + "assert_not_selected_tab", + "assert_not_showing_unread_only", + "assert_not_shown", + "assert_nothing_selected", + "assert_number_of_tabs_open", + "assert_pane_layout", + "assert_selected", + "assert_selected_and_displayed", + "assert_selected_tab", + "assert_showing_unread_only", + "assert_summary_contains_N_elts", + "assert_tab_has_title", + "assert_tab_mode_name", + "assert_tab_titled_from", + "assert_thread_tree_focused", + "assert_visible", + "be_in_folder", + "click_tree_row", + "close_message_window", + "close_popup", + "close_tab", + "collapse_all_threads", + "collapse_folder", + "create_encrypted_smime_message", + "create_encrypted_openpgp_message", + "create_folder", + "create_message", + "create_thread", + "create_virtual_folder", + "delete_messages", + "delete_via_popup", + "display_message_in_folder_tab", + "empty_folder", + "enter_folder", + "expand_all_threads", + "expand_folder", + "FAKE_SERVER_HOSTNAME", + "focus_folder_tree", + "focus_message_pane", + "focus_multimessage_pane", + "focus_thread_tree", + "gDefaultWindowHeight", + "gDefaultWindowWidth", + "get_about_3pane", + "get_about_message", + "get_smart_folder_named", + "get_special_folder", + "inboxFolder", + "kClassicMailLayout", + "kVerticalMailLayout", + "kWideMailLayout", + "make_display_grouped", + "make_display_threaded", + "make_display_unthreaded", + "make_message_sets_in_folders", + "mc", + "middle_click_on_folder", + "middle_click_on_row", + "msgGen", + "normalize_for_json", + "open_folder_in_new_tab", + "open_folder_in_new_window", + "open_message_from_file", + "open_selected_message", + "open_selected_message_in_new_tab", + "open_selected_message_in_new_window", + "open_selected_messages", + "plan_for_message_display", + "plan_to_wait_for_folder_events", + "press_delete", + "press_enter", + "remove_from_toolbar", + "reset_close_message_on_delete", + "reset_context_menu_background_tabs", + "reset_open_message_behavior", + "restore_default_window_size", + "right_click_on_folder", + "right_click_on_row", + "select_click_folder", + "select_click_row", + "select_column_click_row", + "select_control_click_row", + "select_none", + "select_shift_click_folder", + "select_shift_click_row", + "set_close_message_on_delete", + "set_context_menu_background_tabs", + "set_mail_view", + "set_mc", + "set_open_message_behavior", + "set_pane_layout", + "set_show_unread_only", + "show_folder_pane", + "smimeUtils_ensureNSS", + "smimeUtils_loadCertificateAndKey", + "smimeUtils_loadPEMCertificate", + "switch_tab", + "throw_and_dump_view_state", + "toggle_main_menu", + "toggle_message_pane", + "toggle_thread_row", + "wait_for_all_messages_to_load", + "wait_for_blank_content_pane", + "wait_for_folder_events", + "wait_for_message_display_completion", + "wait_for_popup_to_open", +]; + +var { AppConstants } = ChromeUtils.importESModule( + "resource://gre/modules/AppConstants.sys.mjs" +); + +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +// the windowHelper module +var windowHelper = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); +var { TestUtils } = ChromeUtils.import( + "resource://testing-common/TestUtils.jsm" +); + +var nsMsgViewIndex_None = 0xffffffff; +var { MailConsts } = ChromeUtils.import("resource:///modules/MailConsts.jsm"); +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); +var { MailUtils } = ChromeUtils.import("resource:///modules/MailUtils.jsm"); +var { MessageGenerator, MessageScenarioFactory, SyntheticMessageSet } = + ChromeUtils.import("resource://testing-common/mailnews/MessageGenerator.jsm"); +var { MessageInjection } = ChromeUtils.import( + "resource://testing-common/mailnews/MessageInjection.jsm" +); +var { SmimeUtils } = ChromeUtils.import( + "resource://testing-common/mailnews/smimeUtils.jsm" +); +var { dump_view_state } = ChromeUtils.import( + "resource://testing-common/mozmill/ViewHelpers.jsm" +); + +/** + * Server hostname as set in runtest.py + */ +var FAKE_SERVER_HOSTNAME = "tinderbox123"; + +/** The controller for the main 3-pane window. */ +var mc; +function set_mc(value) { + mc = value; +} + +/** the index of the current 'other' tab */ +var otherTab; + +var testHelperModule; + +var msgGen; + +var messageInjection; + +msgGen = new MessageGenerator(); +var msgGenFactory = new MessageScenarioFactory(msgGen); + +var inboxFolder = null; + +// logHelper exports +var normalize_for_json; + +// Default size of the main Thunderbird window in which the tests will run. +var gDefaultWindowWidth = 1024; +var gDefaultWindowHeight = 768; + +var initialized = false; +function setupModule() { + if (initialized) { + return; + } + initialized = true; + + testHelperModule = { + Cc, + Ci, + Cu, + // fake some xpcshell stuff + _TEST_FILE: ["mozmill"], + _do_not_wrap_xpcshell: true, + do_throw(aMsg) { + throw new Error(aMsg); + }, + do_check_eq() {}, + do_check_neq() {}, + gDEPTH: "../../", + }; + + // -- logging + + // The xpcshell test resources assume they are loaded into a single global + // namespace, so we need to help them out to maintain their delusion. + load_via_src_path( + "../../../testing/mochitest/resources/logHelper.js", + testHelperModule + ); + // - Hook-up logHelper to the mozmill event system... + normalize_for_json = testHelperModule._normalize_for_json; + + mc = windowHelper.wait_for_existing_window("mail:3pane"); + + setupAccountStuff(); +} +setupModule(); + +function get_about_3pane(win = mc.window) { + let tabmail = win.document.getElementById("tabmail"); + if (tabmail?.currentTabInfo.mode.name == "mail3PaneTab") { + return tabmail.currentAbout3Pane; + } + throw new Error("The current tab is not a mail3PaneTab."); +} + +function get_about_message(win = mc.window) { + let doc = win.document; + let tabmail = doc.getElementById("tabmail"); + if (tabmail?.currentTabInfo.mode.name == "mailMessageTab") { + return tabmail.currentAboutMessage; + } else if (tabmail?.currentTabInfo.mode.name == "mail3PaneTab") { + // Not `currentAboutMessage`, we'll return a value even if it's hidden. + return get_about_3pane(win).messageBrowser.contentWindow; + } else if ( + doc.documentElement.getAttribute("windowtype") == "mail:messageWindow" + ) { + return doc.getElementById("messageBrowser").contentWindow; + } + throw new Error("The current tab is not a mail3PaneTab or mailMessageTab."); +} + +function ready_about_win(win) { + if (win.document.readyState == "complete") { + return; + } + utils.waitFor( + () => win.document.readyState == "complete", + `About win should complete loading` + ); +} + +function get_about_3pane_or_about_message(win = mc.window) { + let doc = win.document; + let tabmail = doc.getElementById("tabmail"); + if ( + tabmail && + ["mail3PaneTab", "mailMessageTab"].includes( + tabmail.currentTabInfo.mode.name + ) + ) { + return tabmail.currentTabInfo.chromeBrowser.contentWindow; + } else if ( + doc.documentElement.getAttribute("windowtype") == "mail:messageWindow" + ) { + return doc.getElementById("messageBrowser").contentWindow; + } + throw new Error("The current tab is not a mail3PaneTab or mailMessageTab."); +} + +function get_db_view(win = mc.window) { + let aboutMessageWin = get_about_3pane_or_about_message(win); + ready_about_win(aboutMessageWin); + return aboutMessageWin.gDBView; +} + +function smimeUtils_ensureNSS() { + SmimeUtils.ensureNSS(); +} + +function smimeUtils_loadPEMCertificate(file, certType, loadKey = false) { + SmimeUtils.loadPEMCertificate(file, certType, loadKey); +} + +function smimeUtils_loadCertificateAndKey(file, pw) { + SmimeUtils.loadCertificateAndKey(file, pw); +} + +function setupAccountStuff() { + messageInjection = new MessageInjection( + { + mode: "local", + }, + msgGen + ); + inboxFolder = messageInjection.getInboxFolder(); +} + +/* + * Although we all agree that the use of generators when dealing with async + * operations is awesome, the mozmill idiom is for calls to be synchronous and + * just spin event loops when they need to wait for things to happen. This + * does make the test code significantly less confusing, so we do it too. + * All of our operations are synchronous and just spin until they are happy. + */ + +/** + * Create a folder and rebuild the folder tree view. + * + * @param {string} aFolderName - A folder name with no support for hierarchy at this time. + * @param {nsMsgFolderFlags} [aSpecialFlags] An optional list of nsMsgFolderFlags bits to set. + * @returns {nsIMsgFolder} + */ +async function create_folder(aFolderName, aSpecialFlags) { + wait_for_message_display_completion(); + + let folder = await messageInjection.makeEmptyFolder( + aFolderName, + aSpecialFlags + ); + return folder; +} + +/** + * Create a virtual folder by deferring to |MessageInjection.makeVirtualFolder| and making + * sure to rebuild the folder tree afterwards. + * + * @see MessageInjection.makeVirtualFolder + * @returns {nsIMsgFolder} + */ +function create_virtual_folder(...aArgs) { + let folder = messageInjection.makeVirtualFolder(...aArgs); + return folder; +} + +/** + * Get special folder having a folder flag under Local Folders. + * This function clears the contents of the folder by default. + * + * @param aFolderFlag Folder flag of the required folder. + * @param aCreate Create the folder if it does not exist yet. + * @param aEmpty Set to false if messages from the folder must not be emptied. + */ +async function get_special_folder( + aFolderFlag, + aCreate = false, + aServer, + aEmpty = true +) { + let folderNames = new Map([ + [Ci.nsMsgFolderFlags.Drafts, "Drafts"], + [Ci.nsMsgFolderFlags.Templates, "Templates"], + [Ci.nsMsgFolderFlags.Queue, "Outbox"], + [Ci.nsMsgFolderFlags.Inbox, "Inbox"], + ]); + + let folder = ( + aServer ? aServer : MailServices.accounts.localFoldersServer + ).rootFolder.getFolderWithFlags(aFolderFlag); + + if (!folder && aCreate) { + folder = await create_folder(folderNames.get(aFolderFlag), [aFolderFlag]); + } + if (!folder) { + throw new Error("Special folder not found"); + } + + // Ensure the folder is empty so that each test file can puts its new messages in it + // and they are always at reliable positions (starting from 0). + if (aEmpty) { + await empty_folder(folder); + } + + return folder; +} + +/** + * Create a thread with the specified number of messages in it. + * + * @param {number} aCount + * @returns {SyntheticMessageSet} + */ +function create_thread(aCount) { + return new SyntheticMessageSet(msgGenFactory.directReply(aCount)); +} + +/** + * Create and return a SyntheticMessage object. + * + * @param {MakeMessageOptions} aArgs An arguments object to be passed to + * MessageGenerator.makeMessage() + * @returns {SyntheticMessage} + */ +function create_message(aArgs) { + return msgGen.makeMessage(aArgs); +} + +/** + * Create and return an SMIME SyntheticMessage object. + * + * @param {MakeMessageOptions} aArgs An arguments object to be passed to + * MessageGenerator.makeEncryptedSMimeMessage() + */ +function create_encrypted_smime_message(aArgs) { + return msgGen.makeEncryptedSMimeMessage(aArgs); +} + +/** + * Create and return an OpenPGP SyntheticMessage object. + * + * @param {MakeMessageOptions} aArgs An arguments object to be passed to + * MessageGenerator.makeEncryptedOpenPGPMessage() + */ +function create_encrypted_openpgp_message(aArgs) { + return msgGen.makeEncryptedOpenPGPMessage(aArgs); +} + +/** + * Adds a SyntheticMessage as a SyntheticMessageSet to a folder or folders. + * + * @see MessageInjection.addSetsToFolders + * @param {SyntheticMessage} aMsg + * @param {nsIMsgFolder[]} aFolder + */ +async function add_message_to_folder(aFolder, aMsg) { + await messageInjection.addSetsToFolders(aFolder, [ + new SyntheticMessageSet([aMsg]), + ]); +} + +/** + * Adds SyntheticMessageSets to a folder or folders. + * + * @see MessageInjection.addSetsToFolders + * @param {nsIMsgLocalMailFolder[]} aFolders + * @param {SyntheticMessageSet[]} aMsg + */ +async function add_message_sets_to_folders(aFolders, aMsg) { + await messageInjection.addSetsToFolders(aFolders, aMsg); +} +/** + * Makes SyntheticMessageSets in aFolders + * + * @param {nsIMsgFolder[]} aFolders + * @param {MakeMessageOptions[]} aOptions + * @returns {SyntheticMessageSet[]} + */ +async function make_message_sets_in_folders(aFolders, aOptions) { + return messageInjection.makeNewSetsInFolders(aFolders, aOptions); +} + +/** + * @param {SyntheticMessageSet} aSynMessageSet The set of messages + * to delete. The messages do not all + * have to be in the same folder, but we have to delete them folder by + * folder if they are not. + */ +async function delete_messages(aSynMessageSet) { + await MessageInjection.deleteMessages(aSynMessageSet); +} + +/** + * Make sure we are entering the folder from not having been in the folder. We + * will leave the folder and come back if we have to. + */ +async function enter_folder(aFolder) { + let win = get_about_3pane(); + + // If we're already selected, go back to the root... + if (win.gFolder == aFolder) { + await enter_folder(aFolder.rootFolder); + } + + let displayPromise = BrowserTestUtils.waitForEvent(win, "folderURIChanged"); + win.displayFolder(aFolder.URI); + await displayPromise; + + // Drain the event queue. + utils.sleep(0); +} + +/** + * Make sure we are in the given folder, entering it if we were not. + * + * @returns The tab info of the current tab (a more persistent identifier for + * tabs than the index, which will change as tabs open/close). + */ +async function be_in_folder(aFolder) { + let win = get_about_3pane(); + if (win.gFolder != aFolder) { + await enter_folder(aFolder); + } + return mc.window.document.getElementById("tabmail").currentTabInfo; +} + +/** + * Create a new tab displaying a folder, making that tab the current tab. This + * does not wait for message completion, because it doesn't know whether a + * message display will be triggered. If you know that a message display will be + * triggered, you should follow this up with + * |wait_for_message_display_completion(mc, true)|. If you know that a blank + * pane should be displayed, you should follow this up with + * |wait_for_blank_content_pane()| instead. + * + * @returns The tab info of the current tab (a more persistent identifier for + * tabs than the index, which will change as tabs open/close). + */ +async function open_folder_in_new_tab(aFolder) { + otherTab = mc.window.document.getElementById("tabmail").currentTabInfo; + + let tab = mc.window.openTab( + "mail3PaneTab", + { folderURI: aFolder.URI }, + "tab" + ); + if ( + tab.chromeBrowser.docShell.isLoadingDocument || + tab.chromeBrowser.currentURI.spec != "about:3pane" + ) { + await BrowserTestUtils.browserLoaded(tab.chromeBrowser); + } + await TestUtils.waitForCondition(() => tab.folder == aFolder); + + return tab; +} + +/** + * Open a new mail:3pane window displaying a folder. + * + * @param aFolder the folder to be displayed in the new window + * @returns the augmented controller for the new window + */ +function open_folder_in_new_window(aFolder) { + windowHelper.plan_for_new_window("mail:3pane"); + mc.window.MsgOpenNewWindowForFolder(aFolder.URI); + let mail3pane = windowHelper.wait_for_new_window("mail:3pane"); + return mail3pane; +} + +/** + * Open the selected message(s) by pressing Enter. The mail.openMessageBehavior + * pref is supposed to determine how the messages are opened. + * + * Since we don't know where this is going to trigger a message load, you're + * going to have to wait for message display completion yourself. + * + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +function open_selected_messages(aController) { + if (aController == null) { + aController = mc; + } + // Focus the thread tree + focus_thread_tree(); + // Open whatever's selected + press_enter(aController); +} + +var open_selected_message = open_selected_messages; + +/** + * Create a new tab displaying the currently selected message, making that tab + * the current tab. We block until the message finishes loading. + * + * @param aBackground [optional] If true, then the tab is opened in the + * background. If false or not given, then the tab is opened + * in the foreground. + * + * @returns The tab info of the new tab (a more persistent identifier for tabs + * than the index, which will change as tabs open/close). + */ +async function open_selected_message_in_new_tab(aBackground) { + // get the current tab count so we can make sure the tab actually opened. + let preCount = + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length; + + // save the current tab as the 'other' tab + otherTab = mc.window.document.getElementById("tabmail").currentTabInfo; + + let win = get_about_3pane(); + let message = win.gDBView.hdrForFirstSelectedMessage; + let tab = mc.window.document + .getElementById("tabmail") + .openTab("mailMessageTab", { + messageURI: message.folder.getUriForMsg(message), + viewWrapper: win.gViewWrapper, + background: aBackground, + }); + + if ( + tab.chromeBrowser.docShell.isLoadingDocument || + tab.chromeBrowser.currentURI.spec != "about:message" + ) { + await BrowserTestUtils.browserLoaded(tab.chromeBrowser); + } + + if (!aBackground) { + wait_for_message_display_completion(undefined, true); + } + + // check that the tab count increased + if ( + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length != + preCount + 1 + ) { + throw new Error("The tab never actually got opened!"); + } + + return tab; +} + +/** + * Create a new window displaying the currently selected message. We do not + * return until the message has finished loading. + * + * @returns The MozmillController-wrapped new window. + */ +async function open_selected_message_in_new_window() { + let win = get_about_3pane(); + let newWindowPromise = + windowHelper.async_plan_for_new_window("mail:messageWindow"); + mc.window.MsgOpenNewWindowForMessage( + win.gDBView.hdrForFirstSelectedMessage, + win.gViewWrapper + ); + let msgc = await newWindowPromise; + wait_for_message_display_completion(msgc, true); + return msgc; +} + +/** + * Display the given message in a folder tab. This doesn't make any assumptions + * about whether a new tab is opened, since that is dependent on a user + * preference. However, we do check that the tab we're returning is a folder + * tab. + * + * @param aMsgHdr The message header to display. + * @param [aExpectNew3Pane] This should be set to true if it is expected that a + * new 3-pane window will be opened as a result of + * the API call. + * + * @returns The currently selected tab, guaranteed to be a folder tab. + */ +function display_message_in_folder_tab(aMsgHdr, aExpectNew3Pane) { + if (aExpectNew3Pane) { + windowHelper.plan_for_new_window("mail:3pane"); + } + MailUtils.displayMessageInFolderTab(aMsgHdr); + if (aExpectNew3Pane) { + mc = windowHelper.wait_for_new_window("mail:3pane"); + } + + // Make sure that the tab we're returning is a folder tab + let currentTab = mc.window.document.getElementById("tabmail").currentTabInfo; + assert_tab_mode_name(currentTab, "mail3PaneTab"); + + return currentTab; +} + +/** + * Create a new window displaying a message loaded from a file. We do not + * return until the message has finished loading. + * + * @param file An nsIFile to load the message from. + * @returns The MozmillController-wrapped new window. + */ +async function open_message_from_file(file) { + if (!file.isFile() || !file.isReadable()) { + throw new Error( + "The requested message file " + + file.leafName + + " was not found or is not accessible." + ); + } + + let fileURL = Services.io.newFileURI(file).QueryInterface(Ci.nsIFileURL); + fileURL = fileURL + .mutate() + .setQuery("type=application/x-message-display") + .finalize(); + + let newWindowPromise = + windowHelper.async_plan_for_new_window("mail:messageWindow"); + let win = mc.window.openDialog( + "chrome://messenger/content/messageWindow.xhtml", + "_blank", + "all,chrome,dialog=no,status,toolbar", + fileURL + ); + await BrowserTestUtils.waitForEvent(win, "load"); + let aboutMessage = get_about_message(win); + await BrowserTestUtils.waitForEvent(aboutMessage, "MsgLoaded"); + + let msgc = await newWindowPromise; + wait_for_message_display_completion(msgc, true); + windowHelper.wait_for_window_focused(msgc.window); + utils.sleep(0); + + return msgc; +} + +/** + * Switch to another folder or message tab. If no tab is specified, we switch + * to the 'other' tab. That is the last tab we used, most likely the tab that + * was current when we created this tab. + * + * @param aNewTab Optional, index of the other tab to switch to. + */ +async function switch_tab(aNewTab) { + if (typeof aNewTab == "number") { + aNewTab = mc.window.document.getElementById("tabmail").tabInfo[aNewTab]; + } + + // If the new tab is the same as the current tab, none of the below applies. + // Get out now. + if (aNewTab == mc.window.document.getElementById("tabmail").currentTabInfo) { + return; + } + + let targetTab = aNewTab != null ? aNewTab : otherTab; + // now the current tab will be the 'other' tab after we switch + otherTab = mc.window.document.getElementById("tabmail").currentTabInfo; + let selectPromise = BrowserTestUtils.waitForEvent( + mc.window.document.getElementById("tabmail").tabContainer, + "select" + ); + mc.window.document.getElementById("tabmail").switchToTab(targetTab); + await selectPromise; +} + +/** + * Assert that the currently selected tab is the given one. + * + * @param aTab The tab that should currently be selected. + */ +function assert_selected_tab(aTab) { + Assert.equal( + mc.window.document.getElementById("tabmail").currentTabInfo, + aTab + ); +} + +/** + * Assert that the currently selected tab is _not_ the given one. + * + * @param aTab The tab that should currently not be selected. + */ +function assert_not_selected_tab(aTab) { + Assert.notEqual( + mc.window.document.getElementById("tabmail").currentTabInfo, + aTab + ); +} + +/** + * Assert that the given tab has the given mode name. Valid mode names include + * "message" and "folder". + * + * @param aTab A Tab. The currently selected tab if null. + * @param aModeName A string that should match the mode name of the tab. + */ +function assert_tab_mode_name(aTab, aModeName) { + if (!aTab) { + aTab = mc.window.document.getElementById("tabmail").currentTabInfo; + } + + Assert.equal(aTab.mode.name, aModeName, `Tab should be of type ${aModeName}`); +} + +/** + * Assert that the number of tabs open matches the value given. + * + * @param aNumber The number of tabs that should be open. + */ +function assert_number_of_tabs_open(aNumber) { + let actualNumber = + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length; + Assert.equal(actualNumber, aNumber, `There should be ${aNumber} tabs open`); +} + +/** + * Assert that the given tab's title is based on the provided folder or + * message. + * + * @param aTab A Tab. + * @param aWhat Either an nsIMsgFolder or an nsIMsgDBHdr + */ +function assert_tab_titled_from(aTab, aWhat) { + let text; + if (aWhat instanceof Ci.nsIMsgFolder) { + text = aWhat.prettyName; + } else if (aWhat instanceof Ci.nsIMsgDBHdr) { + text = aWhat.mime2DecodedSubject; + } + + utils.waitFor( + () => aTab.title.includes(text), + `Tab title should include '${text}' but does not. (Current title: '${aTab.title}')` + ); +} + +/** + * Assert that the given tab's title is what is given. + * + * @param aTab The tab to check. + * @param aTitle The title to check. + */ +function assert_tab_has_title(aTab, aTitle) { + Assert.equal(aTab.title, aTitle); +} + +/** + * Close a tab. If no tab is specified, it is assumed you want to close the + * current tab. + */ +function close_tab(aTabToClose) { + if (typeof aTabToClose == "number") { + aTabToClose = + mc.window.document.getElementById("tabmail").tabInfo[aTabToClose]; + } + + // Get the current tab count so we can make sure the tab actually closed. + let preCount = + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length; + + mc.window.document.getElementById("tabmail").closeTab(aTabToClose); + + // Check that the tab count decreased. + if ( + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length != + preCount - 1 + ) { + throw new Error("The tab never actually got closed!"); + } +} + +/** + * Close a message window by calling window.close() on the controller. + */ +function close_message_window(aController) { + windowHelper.close_window(aController); +} + +/** + * Clear the selection. I'm not sure how we're pretending we did that, but + * we explicitly focus the thread tree as a side-effect. + */ +function select_none(aController) { + if (aController == null) { + aController = mc; + } + wait_for_message_display_completion(); + focus_thread_tree(); + get_db_view(aController.window).selection.clearSelection(); + get_about_3pane().threadTree.dispatchEvent(new CustomEvent("select")); + // Because the selection event may not be generated immediately, we need to + // spin until the message display thinks it is not displaying a message, + // which is the sign that the event actually happened. + let win2 = get_about_message(); + function noMessageChecker() { + return win2.gMessage == null; + } + try { + utils.waitFor(noMessageChecker); + } catch (e) { + if (e instanceof utils.TimeoutError) { + Assert.report( + true, + undefined, + undefined, + "Timeout waiting for displayedMessage to become null." + ); + } else { + throw e; + } + } + wait_for_blank_content_pane(aController); +} + +/** + * Normalize a view index to be an absolute index, handling slice-style negative + * references as well as piercing complex things like message headers and + * synthetic message sets. + * + * @param aViewIndex An absolute index (integer >= 0), slice-style index (< 0), + * or a SyntheticMessageSet (we only care about the first message in it). + */ +function _normalize_view_index(aViewIndex) { + let dbView = get_db_view(); + + // SyntheticMessageSet special-case + if (typeof aViewIndex != "number") { + let msgHdrIter = aViewIndex.msgHdrs(); + let msgHdr = msgHdrIter.next().value; + msgHdrIter.return(); + // do not expand + aViewIndex = dbView.findIndexOfMsgHdr(msgHdr, false); + } + + if (aViewIndex < 0) { + return dbView.rowCount + aViewIndex; + } + return aViewIndex; +} + +/** + * Generic method to simulate a left click on a row in a <tree> element. + * + * @param {XULTreeElement} aTree - The tree element. + * @param {number} aRowIndex - Index of a row in the tree to click on. + * @param {MozMillController} aController - Controller object. + * @see mailTestUtils.treeClick for another way. + */ +function click_tree_row(aTree, aRowIndex, aController) { + if (aRowIndex < 0 || aRowIndex >= aTree.view.rowCount) { + throw new Error( + "Row " + aRowIndex + " does not exist in the tree " + aTree.id + "!" + ); + } + + let selection = aTree.view.selection; + selection.select(aRowIndex); + aTree.ensureRowIsVisible(aRowIndex); + + // get cell coordinates + let column = aTree.columns[0]; + let coords = aTree.getCoordsForCellItem(aRowIndex, column, "text"); + + utils.sleep(0); + EventUtils.synthesizeMouse( + aTree.body, + coords.x + 4, + coords.y + 4, + {}, + aTree.ownerGlobal + ); + utils.sleep(0); +} + +function _get_row_at_index(aViewIndex) { + let win = get_about_3pane(); + let tree = win.document.getElementById("threadTree"); + Assert.greater( + tree.view.rowCount, + aViewIndex, + `index ${aViewIndex} must exist to be clicked on` + ); + tree.scrollToIndex(aViewIndex, true); + utils.waitFor(() => tree.getRowAtIndex(aViewIndex)); + return tree.getRowAtIndex(aViewIndex); +} + +/** + * Pretend we are clicking on a row with our mouse. + * + * @param aViewIndex If >= 0, the view index provided, if < 0, a reference to + * a view index counting from the last row in the tree. -1 indicates the + * last message in the tree, -2 the second to last, etc. + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + * + * @returns The message header selected. + */ +function select_click_row(aViewIndex) { + aViewIndex = _normalize_view_index(aViewIndex); + + let row = _get_row_at_index(aViewIndex); + EventUtils.synthesizeMouseAtCenter(row, {}, row.ownerGlobal); + utils.sleep(0); + + wait_for_message_display_completion(undefined, true); + + return get_about_3pane().gDBView.getMsgHdrAt(aViewIndex); +} + +/** + * Pretend we are clicking on a row in the select column with our mouse. + * + * @param aViewIndex - If >= 0, the view index provided, if < 0, a reference to + * a view index counting from the last row in the tree. -1 indicates the + * last message in the tree, -2 the second to last, etc. + * @param aController - The controller in whose context to do this, defaults to + * |mc| if omitted. + * + * @returns The message header selected. + */ +function select_column_click_row(aViewIndex, aController) { + if (aController == null) { + aController = mc; + } + + let dbView = get_db_view(aController.window); + + let hasMessageDisplay = "messageDisplay" in aController; + if (hasMessageDisplay) { + wait_for_message_display_completion(aController); + } + aViewIndex = _normalize_view_index(aViewIndex, aController); + + // A click in the select column will always change the message display. If + // clicking on a single selection (deselect), don't wait for a message load. + var willDisplayMessage = + hasMessageDisplay && + aController.messageDisplay.visible && + !(dbView.selection.count == 1 && dbView.selection.isSelected(aViewIndex)) && + dbView.selection.currentIndex !== aViewIndex; + + if (willDisplayMessage) { + plan_for_message_display(aController); + } + _row_click_helper( + aController, + aController.window.document.getElementById("threadTree"), + aViewIndex, + 0, + null, + "selectCol" + ); + if (hasMessageDisplay) { + wait_for_message_display_completion(aController, willDisplayMessage); + } + return dbView.getMsgHdrAt(aViewIndex); +} + +/** + * Pretend we are toggling the thread specified by a row. + * + * @param aViewIndex If >= 0, the view index provided, if < 0, a reference to + * a view index counting from the last row in the tree. -1 indicates the + * last message in the tree, -2 the second to last, etc. + * + */ +function toggle_thread_row(aViewIndex) { + aViewIndex = _normalize_view_index(aViewIndex); + + let win = get_about_3pane(); + let row = win.document.getElementById("threadTree").getRowAtIndex(aViewIndex); + EventUtils.synthesizeMouseAtCenter(row.querySelector(".twisty"), {}, win); + + wait_for_message_display_completion(); +} + +/** + * Pretend we are clicking on a row with our mouse with the control key pressed, + * resulting in the addition/removal of just that row to/from the selection. + * + * @param aViewIndex If >= 0, the view index provided, if < 0, a reference to + * a view index counting from the last row in the tree. -1 indicates the + * last message in the tree, -2 the second to last, etc. + * + * @returns The message header of the affected message. + */ +function select_control_click_row(aViewIndex) { + aViewIndex = _normalize_view_index(aViewIndex); + + let win = get_about_3pane(); + let row = win.document.getElementById("threadTree").getRowAtIndex(aViewIndex); + EventUtils.synthesizeMouseAtCenter(row, { accelKey: true }, win); + + wait_for_message_display_completion(); + + return win.gDBView.getMsgHdrAt(aViewIndex); +} + +/** + * Pretend we are clicking on a row with our mouse with the shift key pressed, + * adding all the messages between the shift pivot and the shift selected row. + * + * @param aViewIndex If >= 0, the view index provided, if < 0, a reference to + * a view index counting from the last row in the tree. -1 indicates the + * last message in the tree, -2 the second to last, etc. + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + * + * @returns The message headers for all messages that are now selected. + */ +function select_shift_click_row(aViewIndex, aController, aDoNotRequireLoad) { + aViewIndex = _normalize_view_index(aViewIndex, aController); + + let win = get_about_3pane(); + let row = win.document.getElementById("threadTree").getRowAtIndex(aViewIndex); + EventUtils.synthesizeMouseAtCenter(row, { shiftKey: true }, win); + + wait_for_message_display_completion(); + + return win.gDBView.getSelectedMsgHdrs(); +} + +/** + * Helper function to click on a row with a given button. + */ +function _row_click_helper( + aController, + aTree, + aViewIndex, + aButton, + aExtra, + aColumnId +) { + // Force-focus the tree + aTree.focus(); + // coordinates of the upper left of the entire tree widget (headers included) + let treeRect = aTree.getBoundingClientRect(); + let tx = treeRect.x, + ty = treeRect.y; + // coordinates of the row display region of the tree (below the headers) + let children = aController.window.document.getElementById(aTree.id, { + tagName: "treechildren", + }); + let childrenRect = children.getBoundingClientRect(); + let x = childrenRect.x, + y = childrenRect.y; + // Click in the middle of the row by default + let rowX = childrenRect.width / 2; + // For the thread tree, Position our click on the subject column (which cannot + // be hidden), and far enough in that we are in no danger of clicking the + // expand toggler unless that is explicitly requested. + if (aTree.id == "threadTree") { + let columnId = aColumnId || "subjectCol"; + let col = aController.window.document.getElementById(columnId); + rowX = col.getBoundingClientRect().x - tx + 8; + // click on the toggle if so requested (for subjectCol) + if (columnId == "subjectCol" && aExtra !== "toggle") { + rowX += 32; + } + } + // Very important, gotta be able to see the row. + aTree.ensureRowIsVisible(aViewIndex); + let rowY = + aTree.rowHeight * (aViewIndex - aTree.getFirstVisibleRow()) + + aTree.rowHeight / 2; + if (aTree.getRowAt(x + rowX, y + rowY) != aViewIndex) { + throw new Error( + "Thought we would find row " + + aViewIndex + + " at " + + rowX + + "," + + rowY + + " but we found " + + aTree.getRowAt(rowX, rowY) + ); + } + // Generate a mouse-down for all click types; the transient selection + // logic happens on mousedown which our tests assume is happening. (If you + // are using a keybinding to trigger the event, that will not happen, but + // we don't test that.) + EventUtils.synthesizeMouse( + aTree, + x + rowX - tx, + y + rowY - ty, + { + type: "mousedown", + button: aButton, + shiftKey: aExtra === "shift", + accelKey: aExtra === "accel", + }, + aController.window + ); + + // For right-clicks, the platform code generates a "contextmenu" event + // when it sees the mouse press/down event. We are not synthesizing a platform + // level event (though it is in our power; we just historically have not), + // so we need to be the people to create the context menu. + if (aButton == 2) { + EventUtils.synthesizeMouse( + aTree, + x + rowX - tx, + y + rowY - ty, + { type: "contextmenu", button: aButton }, + aController.window + ); + } + + EventUtils.synthesizeMouse( + aTree, + x + rowX - tx, + y + rowY - ty, + { + type: "mouseup", + button: aButton, + shiftKey: aExtra == "shift", + accelKey: aExtra === "accel", + }, + aController.window + ); +} + +/** + * Right-click on the tree-view in question. With any luck, this will have + * the side-effect of opening up a pop-up which it is then on _your_ head + * to do something with or close. However, we have helpful popup function + * helpers because I'm so nice. + * + * @returns The message header that you clicked on. + */ +async function right_click_on_row(aViewIndex) { + aViewIndex = _normalize_view_index(aViewIndex); + + let win = get_about_3pane(); + let shownPromise = BrowserTestUtils.waitForEvent( + win.document.getElementById("mailContext"), + "popupshown" + ); + let row = win.document.getElementById("threadTree").getRowAtIndex(aViewIndex); + EventUtils.synthesizeMouseAtCenter(row, { type: "contextmenu" }, win); + await shownPromise; + + return get_db_view().getMsgHdrAt(aViewIndex); +} + +/** + * Middle-click on the tree-view in question, presumably opening a new message + * tab. + * + * @returns [The new tab, the message that you clicked on.] + */ +function middle_click_on_row(aViewIndex) { + aViewIndex = _normalize_view_index(aViewIndex); + + let win = get_about_3pane(); + let row = _get_row_at_index(aViewIndex); + EventUtils.synthesizeMouseAtCenter(row, { button: 1 }, win); + + return [ + mc.window.document.getElementById("tabmail").tabInfo[ + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length - + 1 + ], + win.gDBView.getMsgHdrAt(aViewIndex), + ]; +} + +/** + * Assert that the given folder mode is the current one. + * + * @param aMode The expected folder mode. + * @param [aController] The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +function assert_folder_mode(aMode, aController) { + let about3Pane = get_about_3pane(aController?.window); + if (!about3Pane.folderPane.activeModes.includes(aMode)) { + throw new Error(`The folder mode "${aMode}" is not visible`); + } +} + +/** + * Assert that the given folder is the child of the given parent in the folder + * tree view. aParent == null is equivalent to saying that the given folder + * should be a top-level folder. + */ +function assert_folder_child_in_view(aChild, aParent) { + let about3Pane = get_about_3pane(); + let childRow = about3Pane.folderPane.getRowForFolder(aChild); + let parentRow = childRow.parentNode.closest("li"); + + if (parentRow?.uri != aParent.URI) { + throw new Error( + "Folder " + + aChild.URI + + " should be the child of " + + (aParent && aParent.URI) + + ", but is actually the child of " + + parentRow?.uri + ); + } +} + +/** + * Assert that the given folder is in the current folder mode and is visible. + * + * @param aFolder The folder to assert as visible + * @param [aController] The controller in whose context to do this, defaults to + * |mc| if omitted. + * @returns The index of the folder, if it is visible. + */ +function assert_folder_visible(aFolder, aController) { + let about3Pane = get_about_3pane(aController?.window); + let folderIndex = about3Pane.folderTree.rows.findIndex( + row => row.uri == aFolder.URI + ); + if (folderIndex == -1) { + throw new Error("Folder: " + aFolder.URI + " should be visible, but isn't"); + } + + return folderIndex; +} + +/** + * Assert that the given folder is either not in the current folder mode at all, + * or is not currently visible. + */ +function assert_folder_not_visible(aFolder) { + let about3Pane = get_about_3pane(); + let folderIndex = about3Pane.folderTree.rows.findIndex( + row => row.uri == aFolder.URI + ); + if (folderIndex != -1) { + throw new Error( + "Folder: " + aFolder.URI + " should not be visible, but is" + ); + } +} + +/** + * Collapse a folder if it has children. This will throw if the folder itself is + * not visible in the folder view. + */ +function collapse_folder(aFolder) { + let folderIndex = assert_folder_visible(aFolder); + let about3Pane = get_about_3pane(); + let folderRow = about3Pane.folderTree.getRowAtIndex(folderIndex); + if (!folderRow.classList.contains("collapsed")) { + EventUtils.synthesizeMouseAtCenter( + folderRow.querySelector(".twisty"), + {}, + about3Pane + ); + } +} + +/** + * Expand a folder if it has children. This will throw if the folder itself is + * not visible in the folder view. + */ +function expand_folder(aFolder) { + let folderIndex = assert_folder_visible(aFolder); + let about3Pane = get_about_3pane(); + let folderRow = about3Pane.folderTree.getRowAtIndex(folderIndex); + if (folderRow.classList.contains("collapsed")) { + EventUtils.synthesizeMouseAtCenter( + folderRow.querySelector(".twisty"), + {}, + about3Pane + ); + } +} + +/** + * Assert that a folder is currently visible and collapsed. This will throw if + * either of the two is untrue. + */ +function assert_folder_collapsed(aFolder) { + let folderIndex = assert_folder_visible(aFolder); + let row = get_about_3pane().folderTree.getRowAtIndex(folderIndex); + Assert.ok(row.classList.contains("collapsed")); +} + +/** + * Assert that a folder is currently visible and expanded. This will throw if + * either of the two is untrue. + */ +function assert_folder_expanded(aFolder) { + let folderIndex = assert_folder_visible(aFolder); + let row = get_about_3pane().folderTree.getRowAtIndex(folderIndex); + Assert.ok(!row.classList.contains("collapsed")); +} + +/** + * Pretend we are clicking on a folder with our mouse. + * + * @param aFolder The folder to click on. This needs to be present in the + * current folder tree view, of course. + * + * @returns the view index that you clicked on. + */ +function select_click_folder(aFolder) { + let win = get_about_3pane(); + let folderTree = win.window.document.getElementById("folderTree"); + let row = folderTree.rows.find(row => row.uri == aFolder.URI); + row.scrollIntoView(); + EventUtils.synthesizeMouseAtCenter(row.querySelector(".container"), {}, win); +} + +/** + * Pretend we are clicking on a folder with our mouse with the shift key pressed. + * + * @param aFolder The folder to shift-click on. This needs to be present in the + * current folder tree view, of course. + * + * @returns An array containing all the folders that are now selected. + */ +function select_shift_click_folder(aFolder) { + wait_for_all_messages_to_load(); + + let viewIndex = mc.folderTreeView.getIndexOfFolder(aFolder); + // Passing -1 as the start range checks the shift-pivot, which should be -1, + // so it should fall over to the current index, which is what we want. It + // will then set the shift-pivot to the previously-current-index and update + // the current index to be what we shift-clicked on. All matches user + // interaction. + mc.folderTreeView.selection.rangedSelect(-1, viewIndex, false); + wait_for_all_messages_to_load(); + // give the event queue a chance to drain... + utils.sleep(0); + + return mc.folderTreeView.getSelectedFolders(); +} + +/** + * Right click on the folder tree view. With any luck, this will have the + * side-effect of opening up a pop-up which it is then on _your_ head to do + * something with or close. However, we have helpful popup function helpers + * helpers because asuth's so nice. + * + * @note The argument is a folder here, unlike in the message case, so beware. + * + * @returns The view index that you clicked on. + */ +async function right_click_on_folder(aFolder) { + let win = get_about_3pane(); + let folderTree = win.window.document.getElementById("folderTree"); + let shownPromise = BrowserTestUtils.waitForEvent( + win.document.getElementById("folderPaneContext"), + "popupshown" + ); + let row = folderTree.rows.find(row => row.uri == aFolder.URI); + EventUtils.synthesizeMouseAtCenter( + row.querySelector(".container"), + { type: "contextmenu" }, + win + ); + await shownPromise; +} + +/** + * Middle-click on the folder tree view, presumably opening a new folder tab. + * + * @note The argument is a folder here, unlike in the message case, so beware. + * + * @returns [The new tab, the view index that you clicked on.] + */ +function middle_click_on_folder(aFolder, shiftPressed) { + let win = get_about_3pane(); + let folderTree = win.window.document.getElementById("folderTree"); + let row = folderTree.rows.find(row => row.uri == aFolder.URI); + EventUtils.synthesizeMouseAtCenter( + row.querySelector(".container"), + { button: 1, shiftKey: shiftPressed }, + win + ); + + return [ + mc.window.document.getElementById("tabmail").tabInfo[ + mc.window.document.getElementById("tabmail").tabContainer.allTabs.length - + 1 + ], + ]; +} + +/** + * Get a reference to the smart folder with the given name. + * + * @param aFolderName The name of the smart folder (e.g. "Inbox"). + * @returns An nsIMsgFolder representing the smart folder with the given name. + */ +function get_smart_folder_named(aFolderName) { + let smartServer = MailServices.accounts.findServer( + "nobody", + "smart mailboxes", + "none" + ); + return smartServer.rootFolder.getChildNamed(aFolderName); +} + +/** + * Assuming the context popup is popped-up (via right_click_on_row), select + * the deletion option. If the popup is not popped up, you are out of luck. + */ +async function delete_via_popup() { + plan_to_wait_for_folder_events( + "DeleteOrMoveMsgCompleted", + "DeleteOrMoveMsgFailed" + ); + let win = get_about_3pane(); + let ctxDelete = win.document.getElementById("mailContext-delete"); + if (AppConstants.platform == "macosx") { + // We need to use click() since the synthesizeMouseAtCenter doesn't work for + // context menu items on macos. + ctxDelete.click(); + } else { + EventUtils.synthesizeMouseAtCenter(ctxDelete, {}, ctxDelete.ownerGlobal); + } + + // for reasons unknown, the pop-up does not close itself? + await close_popup(mc, win.document.getElementById("mailContext")); + wait_for_folder_events(); +} + +async function wait_for_popup_to_open(popupElem) { + if (popupElem.state != "open") { + await BrowserTestUtils.waitForEvent(popupElem, "popupshown"); + } +} + +/** + * Close the open pop-up. + */ +async function close_popup(aController, elem) { + // if it was already closing, just leave + if (elem.state == "closed") { + return; + } + + if (elem.state != "hiding") { + // Actually close the popup because it's not closing/closed. + let hiddenPromise = BrowserTestUtils.waitForEvent(elem, "popuphidden"); + elem.hidePopup(); + await hiddenPromise; + await new Promise(resolve => + aController.window.requestAnimationFrame(resolve) + ); + } +} + +/** + * Pretend we are pressing the delete key, triggering message deletion of the + * selected messages. + * + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + * @param aModifiers (optional) Modifiers to pass to the keypress method. + */ +function press_delete(aController, aModifiers) { + if (aController == null) { + aController = mc; + } + plan_to_wait_for_folder_events( + "DeleteOrMoveMsgCompleted", + "DeleteOrMoveMsgFailed" + ); + + EventUtils.synthesizeKey("VK_DELETE", aModifiers || {}, aController.window); + wait_for_folder_events(); +} + +/** + * Delete all messages in the given folder. + * (called empty_folder similarly to emptyTrash method on root folder) + * + * @param aFolder Folder to empty. + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +async function empty_folder(aFolder, aController = mc) { + if (!aFolder) { + throw new Error("No folder for emptying given"); + } + + await be_in_folder(aFolder); + let msgCount; + while ((msgCount = aFolder.getTotalMessages(false)) > 0) { + select_click_row(0, aController); + press_delete(aController); + utils.waitFor(() => aFolder.getTotalMessages(false) < msgCount); + } +} + +/** + * Archive the selected messages, and wait for it to complete. Archiving + * plans and waits for message display if the display is visible because + * successful archiving will by definition change the currently displayed + * set of messages (unless you are looking at a virtual folder that includes + * the archive folder.) + * + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +function archive_selected_messages(aController) { + if (aController == null) { + aController = mc; + } + + let dbView = get_db_view(aController.window); + + // How many messages do we expect to remain after the archival? + let expectedCount = dbView.rowCount - dbView.numSelected; + + // if (expectedCount && aController.messageDisplay.visible) { + // plan_for_message_display(aController); + // } + EventUtils.synthesizeKey("a", {}, aController.window); + + // Wait for the view rowCount to decrease by the number of selected messages. + let messagesDeletedFromView = function () { + return dbView.rowCount == expectedCount; + }; + utils.waitFor( + messagesDeletedFromView, + "Timeout waiting for messages to be archived" + ); + // wait_for_message_display_completion( + // aController, + // expectedCount && aController.messageDisplay.visible + // ); + // The above may return immediately, meaning the event queue might not get a + // chance. give it a chance now. + utils.sleep(0); +} + +/** + * Pretend we are pressing the Enter key, triggering opening selected messages. + * Note that since we don't know where this is going to trigger a message load, + * you're going to have to wait for message display completion yourself. + * + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +function press_enter(aController) { + if (aController == null) { + aController = mc; + } + // if something is loading, make sure it finishes loading... + if ("messageDisplay" in aController) { + wait_for_message_display_completion(aController); + } + EventUtils.synthesizeKey("VK_RETURN", {}, aController.window); + // The caller's going to have to wait for message display completion +} + +/** + * Wait for the |folderDisplay| on aController (defaults to mc if omitted) to + * finish loading. This generally only matters for folders that have an active + * search. + * This method is generally called automatically most of the time, and you + * should not need to call it yourself unless you are operating outside the + * helper methods in this file. + */ +function wait_for_all_messages_to_load(aController = mc) { + // utils.waitFor( + // () => aController.window.gFolderDisplay.allMessagesLoaded, + // "Messages never finished loading. Timed Out." + // ); + // the above may return immediately, meaning the event queue might not get a + // chance. give it a chance now. + utils.sleep(0); +} + +/** + * Call this before triggering a message display that you are going to wait for + * using |wait_for_message_display_completion| where you are passing true for + * the aLoadDemanded argument. This ensures that if a message is already + * displayed for the given controller that state is sufficiently cleaned up + * so it doesn't trick us into thinking that there is no need to wait. + * + * @param [aControllerOrTab] optional controller or tab, defaulting to |mc|. If + * the message display is going to be caused by a tab switch, a reference to + * the tab to switch to should be passed in. + */ +function plan_for_message_display(aControllerOrTab) {} + +/** + * If a message or summary is in the process of loading, let it finish; + * optionally, be sure to wait for a load to happen (assuming + * |plan_for_message_display| is used, modulo the conditions below.) + * + * This method is used defensively by a lot of other code in this file that is + * really not sure whether there might be a load in progress or not. So by + * default we only do something if there is obviously a message display in + * progress. Since some events may end up getting deferred due to script + * blockers or the like, it is possible the event that triggers the display + * may not have happened by the time you call this. In that case, you should + * + * 1) pass true for aLoadDemanded, and + * 2) invoke |plan_for_message_display| + * + * before triggering the event that will induce a message display. Note that: + * - You cannot do #2 if you are opening a new message window and can assume + * that this will be the first message ever displayed in the window. This is + * fine, because messageLoaded is initially false. + * - You should not do #2 if you are opening a new folder or message tab. That + * is because you'll affect the old tab's message display instead of the new + * tab's display. Again, this is fine, because a new message display will be + * created for the new tab, and messageLoaded will initially be false for it. + * + * If we didn't use this method defensively, we would get horrible assertions + * like so: + * ###!!! ASSERTION: Overwriting an existing document channel! + * + * + * @param [aController] optional controller, defaulting to |mc|. + * @param [aLoadDemanded=false] Should we require that we wait for a message to + * be loaded? You should use this in conjunction with + * |plan_for_message_display| as per the documentation above. If you do + * not pass true and there is no message load in process, this method will + * return immediately. + */ +function wait_for_message_display_completion(aController, aLoadDemanded) { + let win; + if ( + aController == null || + aController.window.document.getElementById("tabmail") + ) { + win = get_about_message(aController?.window); + } else { + win = + aController.window.document.getElementById( + "messageBrowser" + ).contentWindow; + } + + let tabmail = mc.window.document.getElementById("tabmail"); + if (tabmail.currentTabInfo.mode.name == "mail3PaneTab") { + let about3Pane = tabmail.currentAbout3Pane; + if (about3Pane?.gDBView?.getSelectedMsgHdrs().length > 1) { + // Displaying multiple messages. + return; + } + if (about3Pane?.messagePaneSplitter.isCollapsed) { + // Message pane hidden. + return; + } + } + + utils.waitFor(() => win.document.readyState == "complete"); + + let browser = win.getMessagePaneBrowser(); + + try { + utils.waitFor( + () => + !browser.docShell?.isLoadingDocument && + (!aLoadDemanded || browser.currentURI?.spec != "about:blank") + ); + } catch (e) { + if (e instanceof utils.TimeoutError) { + Assert.report( + true, + undefined, + undefined, + `Timeout waiting for a message. Current location: ${browser.currentURI?.spec}` + ); + } else { + throw e; + } + } + + utils.sleep(); +} + +/** + * Wait for the content pane to be blank because no message is to be displayed. + * + * @param aController optional controller, defaulting to |mc|. + */ +function wait_for_blank_content_pane(aController) { + let win; + if (aController == null || aController == mc) { + win = get_about_message(); + } else { + win = aController.window; + } + + utils.waitFor(() => win.document.readyState == "complete"); + + let browser = win.getMessagePaneBrowser(); + if (BrowserTestUtils.is_hidden(browser)) { + return; + } + + try { + utils.waitFor( + () => + !browser.docShell?.isLoadingDocument && + browser.currentURI?.spec == "about:blank" + ); + } catch (e) { + if (e instanceof utils.TimeoutError) { + Assert.report( + true, + undefined, + undefined, + `Timeout waiting for blank content pane. Current location: ${browser.currentURI?.spec}` + ); + } else { + throw e; + } + } + + // the above may return immediately, meaning the event queue might not get a + // chance. give it a chance now. + utils.sleep(); +} + +var FolderListener = { + _inited: false, + ensureInited() { + if (this._inited) { + return; + } + + MailServices.mailSession.AddFolderListener( + this, + Ci.nsIFolderListener.event + ); + + this._inited = true; + }, + + sawEvents: false, + watchingFor: null, + planToWaitFor(...aArgs) { + this.sawEvents = false; + this.watchingFor = aArgs; + }, + + waitForEvents() { + if (this.sawEvents) { + return; + } + let self = this; + try { + utils.waitFor(() => self.sawEvents); + } catch (e) { + if (e instanceof utils.TimeoutError) { + Assert.report( + true, + undefined, + undefined, + `Timeout waiting for events: ${this.watchingFor}` + ); + } else { + throw e; + } + } + }, + + onFolderEvent(aFolder, aEvent) { + if (!this.watchingFor) { + return; + } + if (this.watchingFor.includes(aEvent)) { + this.watchingFor = null; + this.sawEvents = true; + } + }, +}; + +/** + * Plan to wait for an nsIFolderListener.onFolderEvent matching one of the + * provided strings. Call this before you do the thing that triggers the + * event, then call |wait_for_folder_events| after the event. This ensures + * that we see the event, because it might be too late after you initiate + * the thing that would generate the event. + * For example, plan_to_wait_for_folder_events("DeleteOrMoveMsgCompleted", + * "DeleteOrMoveMsgFailed") waits for a deletion completion notification + * when you call |wait_for_folder_events|. + * The waiting is currently un-scoped, so the event happening on any folder + * triggers us. It is expected that you won't try and have multiple events + * in-flight or will augment us when the time comes to have to deal with that. + */ +function plan_to_wait_for_folder_events(...aArgs) { + FolderListener.ensureInited(); + FolderListener.planToWaitFor(...aArgs); +} +function wait_for_folder_events() { + FolderListener.waitForEvents(); +} + +/** + * Assert that the given synthetic message sets are present in the folder + * display. + * + * Verify that the messages in the provided SyntheticMessageSets are the only + * visible messages in the provided DBViewWrapper. If dummy headers are present + * in the view for group-by-sort, the code will ensure that the dummy header's + * underlying header corresponds to a message in the synthetic sets. However, + * you should generally not rely on this code to test for anything involving + * dummy headers. + * + * In the event the view does not contain all of the messages from the provided + * sets or contains messages not in the provided sets, throw_and_dump_view_state + * will be invoked with a human readable explanation of the problem. + * + * @param aSynSets Either a single SyntheticMessageSet or a list of them. + * @param aController Optional controller, which we get the folderDisplay + * property from. If omitted, we use mc. + */ +function assert_messages_in_view(aSynSets, aController) { + if (aController == null) { + aController = mc; + } + if (!("length" in aSynSets)) { + aSynSets = [aSynSets]; + } + + // - Iterate over all the message sets, retrieving the message header. Use + // this to construct a URI to populate a dictionary mapping. + let synMessageURIs = {}; // map URI to message header + for (let messageSet of aSynSets) { + for (let msgHdr of messageSet.msgHdrs()) { + synMessageURIs[msgHdr.folder.getUriForMsg(msgHdr)] = msgHdr; + } + } + + // - Iterate over the contents of the view, nulling out values in + // synMessageURIs for found messages, and exploding for missing ones. + let dbView = get_db_view(aController.window); + let treeView = dbView.QueryInterface(Ci.nsITreeView); + let rowCount = treeView.rowCount; + + for (let iViewIndex = 0; iViewIndex < rowCount; iViewIndex++) { + let msgHdr = dbView.getMsgHdrAt(iViewIndex); + let uri = msgHdr.folder.getUriForMsg(msgHdr); + // expected hit, null it out. (in the dummy case, we will just null out + // twice, which is also why we do an 'in' test and not a value test. + if (uri in synMessageURIs) { + synMessageURIs[uri] = null; + } else { + // the view is showing a message that should not be shown, explode. + throw_and_dump_view_state( + "The view should show the message header" + msgHdr.messageKey + ); + } + } + + // - Iterate over our URI set and make sure every message got nulled out. + for (let uri in synMessageURIs) { + let msgHdr = synMessageURIs[uri]; + if (msgHdr != null) { + throw_and_dump_view_state( + "The view should include the message header" + msgHdr.messageKey + ); + } + } +} + +/** + * Assert the the given message/messages are not present in the view. + * + * @param aMessages Either a single nsIMsgDBHdr or a list of them. + */ +function assert_messages_not_in_view(aMessages) { + if (aMessages instanceof Ci.nsIMsgDBHdr) { + aMessages = [aMessages]; + } + + let dbView = get_db_view(); + for (let msgHdr of aMessages) { + Assert.equal( + dbView.findIndexOfMsgHdr(msgHdr, true), + nsMsgViewIndex_None, + `Message header is present in view but should not be` + ); + } +} +var assert_message_not_in_view = assert_messages_not_in_view; + +/** + * When displaying a folder, assert that the message pane is visible and all the + * menus, splitters, etc. are set up right. + */ +function assert_message_pane_visible() { + let win = get_about_3pane(); + let messagePane = win.document.getElementById("messagePane"); + + Assert.equal( + win.paneLayout.messagePaneVisible, + true, + "The tab does not think that the message pane is visible, but it should!" + ); + Assert.ok( + BrowserTestUtils.is_visible(messagePane), + "The message pane should not be collapsed!" + ); + Assert.equal( + win.messagePaneSplitter.isCollapsed, + false, + "The message pane splitter should not be collapsed!" + ); + + mc.window.view_init(); // Force the view menu to update. + let paneMenuItem = mc.window.document.getElementById("menu_showMessage"); + Assert.equal( + paneMenuItem.getAttribute("checked"), + "true", + "The Message Pane menu item should be checked." + ); +} + +/** + * When displaying a folder, assert that the message pane is hidden and all the + * menus, splitters, etc. are set up right. + */ +function assert_message_pane_hidden() { + let win = get_about_3pane(); + let messagePane = win.document.getElementById("messagePane"); + + Assert.equal( + win.paneLayout.messagePaneVisible, + false, + "The tab thinks that the message pane is visible, but it shouldn't!" + ); + Assert.ok( + BrowserTestUtils.is_hidden(messagePane), + "The message pane should be collapsed!" + ); + Assert.equal( + win.messagePaneSplitter.isCollapsed, + true, + "The message pane splitter should be collapsed!" + ); + + mc.window.view_init(); // Force the view menu to update. + let paneMenuItem = mc.window.document.getElementById("menu_showMessage"); + Assert.notEqual( + paneMenuItem.getAttribute("checked"), + "true", + "The Message Pane menu item should not be checked." + ); +} + +/** + * Toggle the visibility of the message pane. + */ +function toggle_message_pane() { + EventUtils.synthesizeKey("VK_F8", {}, get_about_3pane()); +} + +/** + * Make the folder pane visible in order to run tests. + * This is necessary as the FolderPane is collapsed if no account is available. + */ +function show_folder_pane() { + mc.window.document.getElementById("folderPaneBox").collapsed = false; +} + +/** + * Helper function for use by assert_selected / assert_selected_and_displayed / + * assert_displayed. + * + * @returns A list of two elements: [MozmillController, [list of view indices]]. + */ +function _process_row_message_arguments(...aArgs) { + let troller = mc; + // - normalize into desired selected view indices + let desiredIndices = []; + for (let arg of aArgs) { + // An integer identifying a view index + if (typeof arg == "number") { + desiredIndices.push(_normalize_view_index(arg)); + } else if (arg instanceof Ci.nsIMsgDBHdr) { + // A message header + // do not expand; the thing should already be selected, eg expanded! + let viewIndex = get_db_view(troller.window).findIndexOfMsgHdr(arg, false); + if (viewIndex == nsMsgViewIndex_None) { + throw_and_dump_view_state( + "Message not present in view that should be there. " + + "(" + + arg.messageKey + + ": " + + arg.mime2DecodedSubject + + ")" + ); + } + desiredIndices.push(viewIndex); + } else if (arg.length == 2 && typeof arg[0] == "number") { + // A list containing two integers, indicating a range of view indices. + let lowIndex = _normalize_view_index(arg[0]); + let highIndex = _normalize_view_index(arg[1]); + for (let viewIndex = lowIndex; viewIndex <= highIndex; viewIndex++) { + desiredIndices.push(viewIndex); + } + } else if (arg.length !== undefined) { + // a List of message headers + for (let iMsg = 0; iMsg < arg.length; iMsg++) { + let msgHdr = arg[iMsg].QueryInterface(Ci.nsIMsgDBHdr); + if (!msgHdr) { + throw new Error(arg[iMsg] + " is not a message header!"); + } + // false means do not expand, it should already be selected + let viewIndex = get_db_view(troller.window).findIndexOfMsgHdr( + msgHdr, + false + ); + if (viewIndex == nsMsgViewIndex_None) { + throw_and_dump_view_state( + "Message not present in view that should be there. " + + "(" + + msgHdr.messageKey + + ": " + + msgHdr.mime2DecodedSubject + + ")" + ); + } + desiredIndices.push(viewIndex); + } + } else if (arg.synMessages) { + // SyntheticMessageSet + for (let msgHdr of arg.msgHdrs()) { + let viewIndex = get_db_view(troller.window).findIndexOfMsgHdr( + msgHdr, + false + ); + if (viewIndex == nsMsgViewIndex_None) { + throw_and_dump_view_state( + "Message not present in view that should be there. " + + "(" + + msgHdr.messageKey + + ": " + + msgHdr.mime2DecodedSubject + + ")" + ); + } + desiredIndices.push(viewIndex); + } + } else if (arg.window) { + // it's a MozmillController + troller = arg; + } else { + throw new Error("Illegal argument: " + arg); + } + } + // sort by integer value + desiredIndices.sort(function (a, b) { + return a - b; + }); + + return [troller, desiredIndices]; +} + +/** + * Asserts that the given set of messages are selected. Unless you are dealing + * with transient selections resulting from right-clicks, you want to be using + * assert_selected_and_displayed because it makes sure that the display is + * correct too. + * + * The arguments consist of one or more of the following: + * - A MozmillController, indicating we should use that controller instead of + * the default, "mc" (corresponding to the 3pane.) Pass this first! + * - An integer identifying a view index. + * - A list containing two integers, indicating a range of view indices. + * - A message header. + * - A list of message headers. + * - A synthetic message set. + */ +function assert_selected(...aArgs) { + let [troller, desiredIndices] = _process_row_message_arguments(...aArgs); + + // - get the actual selection (already sorted by integer value) + let selectedIndices = get_db_view(troller.window).getIndicesForSelection(); + + // - test selection equivalence + // which is the same as string equivalence in this case. muah hah hah. + Assert.equal( + selectedIndices.toString(), + desiredIndices.toString(), + "should have the right selected indices" + ); + return [troller, desiredIndices]; +} + +/** + * Assert that the given set of messages is displayed, but not necessarily + * selected. Unless you are dealing with transient selection issues or some + * other situation where the FolderDisplay should not be correlated with the + * MessageDisplay, you really should be using assert_selected_and_displayed. + * + * The arguments consist of one or more of the following: + * - A MozmillController, indicating we should use that controller instead of + * the default, "mc" (corresponding to the 3pane.) Pass this first! + * - An integer identifying a view index. + * - A list containing two integers, indicating a range of view indices. + * - A message header. + * - A list of message headers. + */ +function assert_displayed(...aArgs) { + let [troller, desiredIndices] = _process_row_message_arguments(...aArgs); + _internal_assert_displayed(false, troller, desiredIndices); +} + +/** + * Assert-that-the-display-is-right logic. We need an internal version so that + * we can know whether we can trust/assert that folderDisplay.selectedMessage + * agrees with messageDisplay, and also so that we don't have to re-compute + * troller and desiredIndices. + */ +function _internal_assert_displayed(trustSelection, troller, desiredIndices) { + // - verify that the right thing is being displayed. + // no selection means folder summary. + if (desiredIndices.length == 0) { + wait_for_blank_content_pane(troller); + + let messageWindow = get_about_message(); + + // folder summary is not landed yet, just verify there is no message. + if (messageWindow.gMessage) { + throw new Error( + "Message display should not think it is displaying a message." + ); + } + // make sure the content pane is pointed at about:blank + let location = messageWindow.getMessagePaneBrowser()?.location; + if (location && location.href != "about:blank") { + throw new Error( + `the content pane should be blank, but is showing: '${location.href}'` + ); + } + } else if (desiredIndices.length == 1) { + /* + // 1 means the message should be displayed + // make sure message display thinks we are in single message display mode + if (!troller.messageDisplay.singleMessageDisplay) { + throw new Error("Message display is not in single message display mode."); + } + // now make sure that we actually are in single message display mode + let singleMessagePane = troller.window.document.getElementById("singleMessage"); + let multiMessagePane = troller.window.document.getElementById("multimessage"); + if (singleMessagePane && singleMessagePane.hidden) { + throw new Error("Single message pane is hidden but it should not be."); + } + if (multiMessagePane && !multiMessagePane.hidden) { + throw new Error("Multiple message pane is visible but it should not be."); + } + + if (trustSelection) { + if ( + troller.window.gFolderDisplay.selectedMessage != + troller.messageDisplay.displayedMessage + ) { + throw new Error( + "folderDisplay.selectedMessage != " + + "messageDisplay.displayedMessage! (fd: " + + troller.window.gFolderDisplay.selectedMessage + + " vs md: " + + troller.messageDisplay.displayedMessage + + ")" + ); + } + } + + let msgHdr = troller.messageDisplay.displayedMessage; + let msgUri = msgHdr.folder.getUriForMsg(msgHdr); + // wait for the document to load so that we don't try and replace it later + // and get that stupid assertion + wait_for_message_display_completion(); + utils.sleep(500) + // make sure the content pane is pointed at the right thing + + let msgService = troller.window.gFolderDisplay.messenger.messageServiceFromURI( + msgUri + ); + let msgUrl = msgService.getUrlForUri( + msgUri, + troller.window.gFolderDisplay.msgWindow + ); + if (troller.window.content?.location.href != msgUrl.spec) { + throw new Error( + "The content pane is not displaying the right message! " + + "Should be: " + + msgUrl.spec + + " but it's: " + + troller.window.content.location.href + ); + } + */ + } else { + /* + // multiple means some form of multi-message summary + // XXX deal with the summarization threshold bail case. + + // make sure the message display thinks we are in multi-message mode + if (troller.messageDisplay.singleMessageDisplay) { + throw new Error( + "Message display should not be in single message display" + + "mode! Desired indices: " + + desiredIndices + ); + } + + // verify that the message pane browser is displaying about:blank + if (mc.window.content && mc.window.content.location.href != "about:blank") { + throw new Error( + "the content pane should be blank, but is showing: '" + + mc.window.content.location.href + + "'" + ); + } + + // now make sure that we actually are in nultiple message display mode + let singleMessagePane = troller.window.document.getElementById("singleMessage"); + let multiMessagePane = troller.window.document.getElementById("multimessage"); + if (singleMessagePane && !singleMessagePane.hidden) { + throw new Error("Single message pane is visible but it should not be."); + } + if (multiMessagePane && multiMessagePane.hidden) { + throw new Error("Multiple message pane is hidden but it should not be."); + } + + // and _now_ make sure that we actually summarized what we wanted to + // summarize. + let desiredMessages = desiredIndices.map(vi => mc.window.gFolderDisplay.view.dbView.getMsgHdrAt(vi)); + assert_messages_summarized(troller, desiredMessages); + */ + } +} + +/** + * Assert that the messages corresponding to the one or more message spec + * arguments are selected and displayed. If you specify multiple messages, + * we verify that the multi-message selection mode is in effect and that they + * are doing the desired thing. (Verifying the summarization may seem + * overkill, but it helps make the tests simpler and allows you to be more + * confident if you're just running one test that everything in the test is + * performing in a sane fashion. Refactoring could be in order, of course.) + * + * The arguments consist of one or more of the following: + * - A MozmillController, indicating we should use that controller instead of + * the default, "mc" (corresponding to the 3pane.) Pass this first! + * - An integer identifying a view index. + * - A list containing two integers, indicating a range of view indices. + * - A message header. + * - A list of message headers. + */ +function assert_selected_and_displayed(...aArgs) { + // make sure the selection is right first. + let [troller, desiredIndices] = assert_selected(...aArgs); + // now make sure the display is right + _internal_assert_displayed(true, troller, desiredIndices); +} + +/** + * Use the internal archiving code for archiving any given set of messages + * + * @param aMsgHdrs a list of message headers + */ +function archive_messages(aMsgHdrs) { + plan_to_wait_for_folder_events( + "DeleteOrMoveMsgCompleted", + "DeleteOrMoveMsgFailed" + ); + + let { MessageArchiver } = ChromeUtils.import( + "resource:///modules/MessageArchiver.jsm" + ); + let batchMover = new MessageArchiver(); + batchMover.archiveMessages(aMsgHdrs); + wait_for_folder_events(); +} + +/** + * Check if the selected messages match the summarized messages. + * + * @param aSummarizedKeys An array of keys (messageKey + folder.URI) for the + * summarized messages. + * @param aSelectedMessages An array of nsIMsgDBHdrs for the selected messages. + * @returns true is aSelectedMessages and aSummarizedKeys refer to the same set + * of messages. + */ +function _verify_summarized_message_set(aSummarizedKeys, aSelectedMessages) { + let summarizedKeys = aSummarizedKeys.slice(); + summarizedKeys.sort(); + // We use the same key-generation as in multimessageview.js. + let selectedKeys = aSelectedMessages.map( + msgHdr => msgHdr.messageKey + msgHdr.folder.URI + ); + selectedKeys.sort(); + + // Stringified versions should now be equal... + return selectedKeys.toString() == summarizedKeys.toString(); +} + +/** + * Asserts that the messages the controller's folder display widget thinks are + * summarized are in fact summarized. This is automatically called by + * assert_selected_and_displayed, so you do not need to call this directly + * unless you are testing the summarization logic. + * + * @param aController The controller who has the summarized display going on. + * @param [aMessages] Optional set of messages to verify. If not provided, this + * is extracted via the folderDisplay. If a SyntheticMessageSet is provided + * we will automatically retrieve what we need from it. + */ +function assert_messages_summarized(aController, aSelectedMessages) { + // - Compensate for selection stabilization code. + // Although WindowHelpers sets the stabilization interval to 0, we + // still need to make sure we have drained the event queue so that it has + // actually gotten a chance to run. + utils.sleep(0); + + // - Verify summary object knows about right messages + if (aSelectedMessages == null) { + aSelectedMessages = aController.window.gFolderDisplay.selectedMessages; + } + // if it's a synthetic message set, we want the headers... + if (aSelectedMessages.synMessages) { + aSelectedMessages = Array.from(aSelectedMessages.msgHdrs()); + } + + let summaryFrame = aController.window.gSummaryFrameManager.iframe; + let summary = summaryFrame.contentWindow.gMessageSummary; + let summarizedKeys = Object.keys(summary._msgNodes); + if (aSelectedMessages.length != summarizedKeys.length) { + let elaboration = + "Summary contains " + + summarizedKeys.length + + " messages, expected " + + aSelectedMessages.length + + "."; + throw new Error( + "Summary does not contain the right set of messages. " + elaboration + ); + } + if (!_verify_summarized_message_set(summarizedKeys, aSelectedMessages)) { + let elaboration = + "Summary: " + summarizedKeys + " Selected: " + aSelectedMessages + "."; + throw new Error( + "Summary does not contain the right set of messages. " + elaboration + ); + } +} + +/** + * Assert that there is nothing selected and, assuming we are in a folder, that + * the folder summary is displayed. + */ +var assert_nothing_selected = assert_selected_and_displayed; + +/** + * Assert that the given view index or message is visible in the thread pane. + */ +function assert_visible(aViewIndexOrMessage) { + let win = get_about_3pane(); + let viewIndex; + if (typeof aViewIndexOrMessage == "number") { + viewIndex = _normalize_view_index(aViewIndexOrMessage); + } else { + viewIndex = win.gDBView.findIndexOfMsgHdr(aViewIndexOrMessage, false); + } + let tree = win.threadTree; + let firstVisibleIndex = tree.getFirstVisibleIndex(); + let lastVisibleIndex = tree.getLastVisibleIndex(); + + if (viewIndex < firstVisibleIndex || viewIndex > lastVisibleIndex) { + throw new Error( + "View index " + + viewIndex + + " is not visible! (" + + firstVisibleIndex + + "-" + + lastVisibleIndex + + " are visible)" + ); + } +} + +/** + * Assert that the given message is now shown in the current view. + */ +function assert_not_shown(aMessages) { + let win = get_about_3pane(); + aMessages.forEach(function (msg) { + let viewIndex = win.gDBView.findIndexOfMsgHdr(msg, false); + if (viewIndex !== nsMsgViewIndex_None) { + throw new Error( + "Message shows; " + msg.messageKey + ": " + msg.mime2DecodedSubject + ); + } + }); +} + +/** + * @param aShouldBeElided Should the messages at the view indices be elided? + * @param aArgs Arguments of the form processed by + * |_process_row_message_arguments|. + */ +function _assert_elided_helper(aShouldBeElided, ...aArgs) { + let [troller, viewIndices] = _process_row_message_arguments(...aArgs); + + let dbView = get_db_view(troller.window); + for (let viewIndex of viewIndices) { + let flags = dbView.getFlagsAt(viewIndex); + if (Boolean(flags & Ci.nsMsgMessageFlags.Elided) != aShouldBeElided) { + throw new Error( + "Message at view index " + + viewIndex + + (aShouldBeElided + ? " should be elided but is not!" + : " should not be elided but is!") + ); + } + } +} + +/** + * Assert that all of the messages at the given view indices are collapsed. + * Arguments should be of the type accepted by |assert_selected_and_displayed|. + */ +function assert_collapsed(...aArgs) { + _assert_elided_helper(true, ...aArgs); +} + +/** + * Assert that all of the messages at the given view indices are expanded. + * Arguments should be of the type accepted by |assert_selected_and_displayed|. + */ +function assert_expanded(...aArgs) { + _assert_elided_helper(false, ...aArgs); +} + +/** + * Add the widget with the given id to the toolbar if it is not already present. + * It gets added to the front if we add it. Use |remove_from_toolbar| to + * remove the widget from the toolbar when you are done. + * + * @param aToolbarElement The DOM element that is the toolbar, like you would + * get from getElementById. + * @param aElementId The id attribute of the toolbaritem item you want added to + * the toolbar (not the id of the thing inside the toolbaritem tag!). + * We take the id name rather than element itself because if not already + * present the element is off floating in DOM limbo. (The toolbar widget + * calls removeChild on the palette.) + */ +function add_to_toolbar(aToolbarElement, aElementId) { + let currentSet = aToolbarElement.currentSet.split(","); + if (!currentSet.includes(aElementId)) { + currentSet.unshift(aElementId); + aToolbarElement.currentSet = currentSet.join(","); + } +} + +/** + * Remove the widget with the given id from the toolbar if it is present. Use + * |add_to_toolbar| to add the item in the first place. + * + * @param aToolbarElement The DOM element that is the toolbar, like you would + * get from getElementById. + * @param aElementId The id attribute of the item you want removed to the + * toolbar. + */ +function remove_from_toolbar(aToolbarElement, aElementId) { + let currentSet = aToolbarElement.currentSet.split(","); + if (currentSet.includes(aElementId)) { + currentSet.splice(currentSet.indexOf(aElementId), 1); + aToolbarElement.currentSet = currentSet.join(","); + } +} + +var RECOGNIZED_WINDOWS = ["messagepane", "multimessage"]; +var RECOGNIZED_ELEMENTS = ["folderTree", "threadTree", "attachmentList"]; + +/** + * Focus the folder tree. + */ +function focus_folder_tree() { + let folderTree = get_about_3pane().document.getElementById("folderTree"); + Assert.ok(BrowserTestUtils.is_visible(folderTree), "folder tree is visible"); + folderTree.focus(); +} + +/** + * Focus the thread tree. + */ +function focus_thread_tree() { + let threadTree = get_about_3pane().document.getElementById("threadTree"); + threadTree.table.body.focus(); +} + +/** + * Focus the (single) message pane. + */ +function focus_message_pane() { + let messageBrowser = + get_about_3pane().document.getElementById("messageBrowser"); + Assert.ok( + BrowserTestUtils.is_visible(messageBrowser), + "message browser is visible" + ); + messageBrowser.focus(); +} + +/** + * Focus the multimessage pane. + */ +function focus_multimessage_pane() { + let multiMessageBrowser = get_about_3pane().document.getElementById( + "multiMessageBrowser" + ); + Assert.ok( + BrowserTestUtils.is_visible(multiMessageBrowser), + "multi message browser is visible" + ); + multiMessageBrowser.focus(); +} + +/** + * Returns a string indicating whatever's currently focused. This will return + * either one of the strings in RECOGNIZED_WINDOWS/RECOGNIZED_ELEMENTS or null. + */ +function _get_currently_focused_thing() { + // If the message pane or multimessage is focused, return that + let focusedWindow = mc.window.document.commandDispatcher.focusedWindow; + if (focusedWindow) { + for (let windowId of RECOGNIZED_WINDOWS) { + let elem = mc.window.document.getElementById(windowId); + if (elem && focusedWindow == elem.contentWindow) { + return windowId; + } + } + } + + // Focused window not recognized, let's try the focused element. + // If an element is focused, it is necessary for the main window to be + // focused. + if (focusedWindow != mc.window) { + return null; + } + + let focusedElement = mc.window.document.commandDispatcher.focusedElement; + let elementsToMatch = RECOGNIZED_ELEMENTS.map(elem => + mc.window.document.getElementById(elem) + ); + while (focusedElement && !elementsToMatch.includes(focusedElement)) { + focusedElement = focusedElement.parentNode; + } + + return focusedElement ? focusedElement.id : null; +} + +function _assert_thing_focused(aThing) { + let focusedThing = _get_currently_focused_thing(); + if (focusedThing != aThing) { + throw new Error( + "The currently focused thing should be " + + aThing + + ", but is actually " + + focusedThing + ); + } +} + +/** + * Assert that the folder tree is focused. + */ +function assert_folder_tree_focused() { + Assert.equal(get_about_3pane().document.activeElement.id, "folderTree"); +} + +/** + * Assert that the thread tree is focused. + */ +function assert_thread_tree_focused() { + let about3Pane = get_about_3pane(); + Assert.equal( + about3Pane.document.activeElement, + about3Pane.threadTree.table.body + ); +} + +/** + * Assert that the (single) message pane is focused. + */ +function assert_message_pane_focused() { + // TODO: this doesn't work. + // let aboutMessageWin = get_about_3pane_or_about_message(); + // ready_about_win(aboutMessageWin); + // Assert.equal( + // aboutMessageWin.document.activeElement.id, + // "messageBrowser" + // ); +} + +/** + * Assert that the multimessage pane is focused. + */ +function assert_multimessage_pane_focused() { + _assert_thing_focused("multimessage"); +} + +/** + * Assert that the attachment list is focused. + */ +function assert_attachment_list_focused() { + _assert_thing_focused("attachmentList"); +} + +function _normalize_folder_view_index(aViewIndex, aController) { + if (aController == null) { + aController = mc; + } + if (aViewIndex < 0) { + return ( + aController.folderTreeView.QueryInterface(Ci.nsITreeView).rowCount + + aViewIndex + ); + } + return aViewIndex; +} + +/** + * Helper function for use by assert_folders_selected / + * assert_folders_selected_and_displayed / assert_folder_displayed. + */ +function _process_row_folder_arguments(...aArgs) { + let troller = mc; + // - normalize into desired selected view indices + let desiredFolders = []; + for (let arg of aArgs) { + // An integer identifying a view index + if (typeof arg == "number") { + let folder = troller.folderTreeView.getFolderForIndex( + _normalize_folder_view_index(arg) + ); + if (!folder) { + throw new Error("Folder index not present in folder view: " + arg); + } + desiredFolders.push(folder); + } else if (arg instanceof Ci.nsIMsgFolder) { + // A folder + desiredFolders.push(arg); + } else if (arg.length == 2 && typeof arg[0] == "number") { + // A list containing two integers, indicating a range of view indices. + let lowIndex = _normalize_folder_view_index(arg[0]); + let highIndex = _normalize_folder_view_index(arg[1]); + for (let viewIndex = lowIndex; viewIndex <= highIndex; viewIndex++) { + desiredFolders.push( + troller.folderTreeView.getFolderForIndex(viewIndex) + ); + } + } else if (arg.length !== undefined) { + // a List of folders + for (let iFolder = 0; iFolder < arg.length; iFolder++) { + let folder = arg[iFolder].QueryInterface(Ci.nsIMsgFolder); + if (!folder) { + throw new Error(arg[iFolder] + " is not a folder!"); + } + desiredFolders.push(folder); + } + } else if (arg.window) { + // it's a MozmillController + troller = arg; + } else { + throw new Error("Illegal argument: " + arg); + } + } + // we can't really sort, so you'll have to grin and bear it + return [troller, desiredFolders]; +} + +/** + * Asserts that the given set of folders is selected. Unless you are dealing + * with transient selections resulting from right-clicks, you want to be using + * assert_folders_selected_and_displayed because it makes sure that the + * display is correct too. + * + * The arguments consist of one or more of the following: + * - A MozmillController, indicating we should use that controller instead of + * the default, "mc" (corresponding to the 3pane.) Pass this first! + * - An integer identifying a view index. + * - A list containing two integers, indicating a range of view indices. + * - An nsIMsgFolder. + * - A list of nsIMsgFolders. + */ +function assert_folders_selected(...aArgs) { + let [troller, desiredFolders] = _process_row_folder_arguments(...aArgs); + + let win = get_about_3pane(); + let folderTree = win.window.document.getElementById("folderTree"); + // - get the actual selection (already sorted by integer value) + let uri = folderTree.rows[folderTree.selectedIndex]?.uri; + let selectedFolders = [MailServices.folderLookup.getFolderForURL(uri)]; + + // - test selection equivalence + // no shortcuts here. check if each folder in either array is present in the + // other array + if ( + desiredFolders.some( + folder => _non_strict_index_of(selectedFolders, folder) == -1 + ) || + selectedFolders.some( + folder => _non_strict_index_of(desiredFolders, folder) == -1 + ) + ) { + throw new Error( + "Desired selection is: " + + _prettify_folder_array(desiredFolders) + + " but actual " + + "selection is: " + + _prettify_folder_array(selectedFolders) + ); + } + + return [troller, desiredFolders]; +} + +var assert_folder_selected = assert_folders_selected; + +/** + * Assert that the given folder is displayed, but not necessarily selected. + * Unless you are dealing with transient selection issues, you really should + * be using assert_folders_selected_and_displayed. + * + * The arguments consist of one or more of the following: + * - A MozmillController, indicating we should use that controller instead of + * the default, "mc" (corresponding to the 3pane.) Pass this first! + * - An integer identifying a view index. + * - A list containing two integers, indicating a range of view indices. + * - An nsIMsgFolder. + * - A list of nsIMsgFolders. + * + * In each case, since we can only have one folder displayed, we only look at + * the first folder you pass in. + */ +function assert_folder_displayed(...aArgs) { + let [troller, desiredFolders] = _process_row_folder_arguments(...aArgs); + Assert.equal( + troller.window.gFolderDisplay.displayedFolder, + desiredFolders[0] + ); +} + +/** + * Asserts that the folders corresponding to the one or more folder spec + * arguments are selected and displayed. If you specify multiple folders, + * we verify that all of them are selected and that the first folder you pass + * in is the one displayed. (If you don't pass in any folders, we can't assume + * anything, so we don't test that case.) + * + * The arguments consist of one or more of the following: + * - A MozmillController, indicating we should use that controller instead of + * the default, "mc" (corresponding to the 3pane.) Pass this first! + * - An integer identifying a view index. + * - A list containing two integers, indicating a range of view indices. + * - An nsIMsgFolder. + * - A list of nsIMsgFolders. + */ +function assert_folders_selected_and_displayed(...aArgs) { + let [, desiredFolders] = assert_folders_selected(...aArgs); + if (desiredFolders.length > 0) { + let win = get_about_3pane(); + Assert.equal(win.gFolder, desiredFolders[0]); + } +} + +var assert_folder_selected_and_displayed = + assert_folders_selected_and_displayed; + +/** + * Assert that there are the given number of rows (not including children of + * collapsed parents) in the folder tree view. + */ +function assert_folder_tree_view_row_count(aCount) { + let about3Pane = get_about_3pane(); + if (about3Pane.folderTree.rowCount != aCount) { + throw new Error( + "The folder tree view's row count should be " + + aCount + + ", but is actually " + + about3Pane.folderTree.rowCount + ); + } +} + +/** + * Assert that the displayed text of the folder at index n equals to str. + */ +function assert_folder_at_index_as(n, str) { + let folderN = mc.window.gFolderTreeView.getFTVItemForIndex(n); + Assert.equal(folderN.text, str); +} + +/** + * Since indexOf does strict equality checking, we need this. + */ +function _non_strict_index_of(aArray, aSearchElement) { + for (let [i, item] of aArray.entries()) { + if (item == aSearchElement) { + return i; + } + } + return -1; +} + +function _prettify_folder_array(aArray) { + return aArray.map(folder => folder.prettyName).join(", "); +} + +/** + * Put the view in unthreaded mode. + */ +function make_display_unthreaded() { + wait_for_message_display_completion(); + get_about_3pane().gViewWrapper.showUnthreaded = true; + // drain event queue + utils.sleep(0); + wait_for_message_display_completion(); +} + +/** + * Put the view in threaded mode. + */ +function make_display_threaded() { + wait_for_message_display_completion(); + get_about_3pane().gViewWrapper.showThreaded = true; + // drain event queue + utils.sleep(0); +} + +/** + * Put the view in group-by-sort mode. + */ +function make_display_grouped() { + wait_for_message_display_completion(); + get_about_3pane().gViewWrapper.showGroupedBySort = true; + // drain event queue + utils.sleep(0); +} + +/** + * Collapse all threads in the current view. + */ +function collapse_all_threads() { + wait_for_message_display_completion(); + get_about_3pane().commandController.doCommand("cmd_collapseAllThreads"); + // drain event queue + utils.sleep(0); +} + +/** + * Set whether to show unread messages only in the current view. + */ +function set_show_unread_only(aShowUnreadOnly) { + wait_for_message_display_completion(); + mc.window.gFolderDisplay.view.showUnreadOnly = aShowUnreadOnly; + wait_for_all_messages_to_load(); + wait_for_message_display_completion(); + // drain event queue + utils.sleep(0); +} + +/** + * Assert that we are showing unread messages only in this view. + */ +function assert_showing_unread_only() { + wait_for_message_display_completion(); + if (!mc.window.gFolderDisplay.view.showUnreadOnly) { + throw new Error( + "The view should be showing unread messages only, but it isn't." + ); + } +} + +/** + * Assert that we are _not_ showing unread messages only in this view. + */ +function assert_not_showing_unread_only() { + wait_for_message_display_completion(); + if (mc.window.gFolderDisplay.view.showUnreadOnly) { + throw new Error( + "The view should not be showing unread messages only, but it is." + ); + } +} + +/** + * Set the mail view filter for the current view. The aData parameter is for + * tags (e.g. you can specify "$label1" for the first tag). + */ +function set_mail_view(aMailViewIndex, aData) { + wait_for_message_display_completion(); + get_about_3pane().gViewWrapper.setMailView(aMailViewIndex, aData); + wait_for_all_messages_to_load(); + wait_for_message_display_completion(); + // drain event queue + utils.sleep(0); +} + +/** + * Assert that the current mail view is as given. See the documentation for + * |set_mail_view| for information about aData. + */ +function assert_mail_view(aMailViewIndex, aData) { + let actualMailViewIndex = mc.window.gFolderDisplay.view.mailViewIndex; + if (actualMailViewIndex != aMailViewIndex) { + throw new Error( + "The mail view index should be " + + aMailViewIndex + + ", but is actually " + + actualMailViewIndex + ); + } + + let actualMailViewData = mc.window.gFolderDisplay.view.mailViewData; + if (actualMailViewData != aData) { + throw new Error( + "The mail view data should be " + + aData + + ", but is actually " + + actualMailViewData + ); + } +} + +/** + * Expand all threads in the current view. + */ +function expand_all_threads() { + wait_for_message_display_completion(); + get_about_3pane().commandController.doCommand("cmd_expandAllThreads"); + // drain event queue + utils.sleep(0); +} + +/** + * Set the mail.openMessageBehavior pref. + * + * @param aPref One of "NEW_WINDOW", "EXISTING_WINDOW" or "NEW_TAB" + */ +function set_open_message_behavior(aPref) { + Services.prefs.setIntPref( + "mail.openMessageBehavior", + MailConsts.OpenMessageBehavior[aPref] + ); +} + +/** + * Reset the mail.openMessageBehavior pref. + */ +function reset_open_message_behavior() { + if (Services.prefs.prefHasUserValue("mail.openMessageBehavior")) { + Services.prefs.clearUserPref("mail.openMessageBehavior"); + } +} + +/** + * Set the mail.tabs.loadInBackground pref. + * + * @param aPref true/false. + */ +function set_context_menu_background_tabs(aPref) { + Services.prefs.setBoolPref("mail.tabs.loadInBackground", aPref); +} + +/** + * Reset the mail.tabs.loadInBackground pref. + */ +function reset_context_menu_background_tabs() { + if (Services.prefs.prefHasUserValue("mail.tabs.loadInBackground")) { + Services.prefs.clearUserPref("mail.tabs.loadInBackground"); + } +} + +/** + * Set the mail.close_message_window.on_delete pref. + * + * @param aPref true/false. + */ +function set_close_message_on_delete(aPref) { + Services.prefs.setBoolPref("mail.close_message_window.on_delete", aPref); +} + +/** + * Reset the mail.close_message_window.on_delete pref. + */ +function reset_close_message_on_delete() { + if (Services.prefs.prefHasUserValue("mail.close_message_window.on_delete")) { + Services.prefs.clearUserPref("mail.close_message_window.on_delete"); + } +} + +/** + * assert that the multimessage/thread summary view contains + * the specified number of elements of the specified selector. + * + * @param aSelector: the CSS selector to use to select + * @param aNumElts: the number of expected elements that have that class + */ + +function assert_summary_contains_N_elts(aSelector, aNumElts) { + let htmlframe = mc.window.document.getElementById("multimessage"); + let matches = htmlframe.contentDocument.querySelectorAll(aSelector); + if (matches.length != aNumElts) { + throw new Error( + "Expected to find " + + aNumElts + + " elements with selector '" + + aSelector + + "', found: " + + matches.length + ); + } +} + +function throw_and_dump_view_state(aMessage, aController) { + dump("******** " + aMessage + "\n"); + dump_view_state(get_db_view(aController?.window)); + throw new Error(aMessage); +} + +/** + * Copy constants from mailWindowOverlay.js + */ + +var kClassicMailLayout = 0; +var kWideMailLayout = 1; +var kVerticalMailLayout = 2; + +/** + * Assert that the expected mail pane layout is shown. + * + * @param aLayout layout code + */ +function assert_pane_layout(aLayout) { + let actualPaneLayout = Services.prefs.getIntPref("mail.pane_config.dynamic"); + if (actualPaneLayout != aLayout) { + throw new Error( + "The mail pane layout should be " + + aLayout + + ", but is actually " + + actualPaneLayout + ); + } +} + +/** + * Change the current mail pane layout. + * + * @param aLayout layout code + */ +function set_pane_layout(aLayout) { + Services.prefs.setIntPref("mail.pane_config.dynamic", aLayout); +} + +/* + * Check window sizes of the main Tb window whether they are at the default values. + * Some tests change the window size so need to be sure what size they start with. + */ +function assert_default_window_size() { + Assert.equal( + mc.window.outerWidth, + gDefaultWindowWidth, + "Main window didn't meet the expected width" + ); + Assert.equal( + mc.window.outerHeight, + gDefaultWindowHeight, + "Main window didn't meet the expected height" + ); +} + +/** + * Restore window to nominal dimensions; saving the size was not working out. + */ +function restore_default_window_size() { + windowHelper.resize_to(mc, gDefaultWindowWidth, gDefaultWindowHeight); +} + +/** + * Toggle visibility of the Main menu bar. + * + * @param {boolean} aEnabled - Whether the menu should be shown or not. + */ +function toggle_main_menu(aEnabled = true) { + let menubar = mc.window.document.getElementById("toolbar-menubar"); + let state = menubar.getAttribute("autohide") != "true"; + menubar.setAttribute("autohide", !aEnabled); + utils.sleep(0); + return state; +} + +/** + * Load a file in its own 'module' (scope really), based on the effective + * location of the staged FolderDisplayHelpers.jsm module. + * + * @param {string} aPath - A path relative to the module (can be just a file name) + * @param {object} aScope - Scope to load the file into. + * + * @returns An object that serves as the global scope for the loaded file. + */ +function load_via_src_path(aPath, aScope) { + let thisFileURL = Cc["@mozilla.org/network/protocol;1?name=resource"] + .getService(Ci.nsIResProtocolHandler) + .resolveURI( + Services.io.newURI( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" + ) + ); + let thisFile = Services.io + .newURI(thisFileURL) + .QueryInterface(Ci.nsIFileURL).file; + + thisFile.setRelativePath; + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.setRelativePath(thisFile, aPath); + // The files are at different paths when tests are run locally vs. CI. + // Plain js files shouldn't really be loaded from a module, but while we + // work on resolving that, try both locations... + if (!file.exists()) { + file.setRelativePath(thisFile, aPath.replace("/testing", "")); + } + if (!file.exists()) { + throw new Error( + `Could not resolve file ${file.path} for path ${aPath} relative to ${thisFile.path}` + ); + } + let uri = Services.io.newFileURI(file).spec; + Services.scriptloader.loadSubScript(uri, aScope); +} diff --git a/comm/mail/test/browser/shared-modules/JunkHelpers.jsm b/comm/mail/test/browser/shared-modules/JunkHelpers.jsm new file mode 100644 index 0000000000..6d53271ed5 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/JunkHelpers.jsm @@ -0,0 +1,97 @@ +/* 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 EXPORTED_SYMBOLS = [ + "mark_selected_messages_as_junk", + "delete_mail_marked_as_junk", +]; + +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); +var { TestUtils } = ChromeUtils.importESModule( + "resource://testing-common/TestUtils.sys.mjs" +); + +var { + mc, + get_about_3pane, + plan_to_wait_for_folder_events, + wait_for_message_display_completion, + wait_for_folder_events, +} = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); + +/** + * Mark the selected messages as junk. This is done by pressing the J key. + * + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +function mark_selected_messages_as_junk(aController) { + if (aController === undefined) { + aController = mc; + } + let win = get_about_3pane(aController.window); + if (aController == mc) { + win.document.getElementById("threadTree").focus(); + } + EventUtils.synthesizeKey("j", {}, win); +} + +/** + * Delete all mail marked as junk in the selected folder. This is done by + * activating the menu option from the Tools menu. + * + * @param aNumDeletesExpected The number of deletes expected. + * @param aController The controller in whose context to do this, defaults to + * |mc| if omitted. + */ +async function delete_mail_marked_as_junk(aNumDeletesExpected, aController) { + if (aController === undefined) { + aController = mc; + } + let win = get_about_3pane(aController.window); + + // Monkey patch and wrap around the deleteJunkInFolder function, mainly for + // the case where deletes aren't expected. + let realDeleteJunkInFolder = win.deleteJunkInFolder; + let numMessagesDeleted = null; + let fakeDeleteJunkInFolder = function () { + numMessagesDeleted = realDeleteJunkInFolder(); + return numMessagesDeleted; + }; + try { + win.deleteJunkInFolder = fakeDeleteJunkInFolder; + + // If something is loading, make sure it finishes loading... + wait_for_message_display_completion(aController); + if (aNumDeletesExpected != 0) { + plan_to_wait_for_folder_events( + "DeleteOrMoveMsgCompleted", + "DeleteOrMoveMsgFailed" + ); + } + + win.goDoCommand("cmd_deleteJunk"); + + if (aNumDeletesExpected != 0) { + wait_for_folder_events(); + } + + // If timeout waiting for numMessagesDeleted to turn non-null, + // this either means that deleteJunkInFolder didn't get called or that it + // didn't return a value." + + await TestUtils.waitForCondition( + () => numMessagesDeleted === aNumDeletesExpected, + `Should have got ${aNumDeletesExpected} deletes, not ${numMessagesDeleted}` + ); + } finally { + win.deleteJunkInFolder = realDeleteJunkInFolder; + } +} diff --git a/comm/mail/test/browser/shared-modules/KeyboardHelpers.jsm b/comm/mail/test/browser/shared-modules/KeyboardHelpers.jsm new file mode 100644 index 0000000000..e99c5bd484 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/KeyboardHelpers.jsm @@ -0,0 +1,58 @@ +/* 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 EXPORTED_SYMBOLS = [ + "input_value", + "delete_existing", + "delete_all_existing", +]; + +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +/** + * Emulates manual input + * + * @param aController The window controller to input keypresses into + * @param aStr The string to input into the control element + * @param aElement (optional) Element on which to perform the input + */ +function input_value(aController, aStr, aElement) { + if (aElement) { + aElement.focus(); + } + for (let i = 0; i < aStr.length; i++) { + EventUtils.synthesizeKey(aStr.charAt(i), {}, aController.window); + } +} + +/** + * Emulates deleting strings via the keyboard + * + * @param aController The window controller to input keypresses into + * @param aElement The element in which to delete characters + * @param aNumber The number of times to press the delete key. + */ +function delete_existing(aController, aElement, aNumber) { + for (let i = 0; i < aNumber; ++i) { + aElement.focus(); + EventUtils.synthesizeKey("VK_BACK_SPACE", {}, aController.window); + } +} + +/** + * Emulates deleting the entire string by pressing Ctrl-A and DEL + * + * @param aController The window controller to input keypresses into + * @param aElement The element in which to delete characters + */ +function delete_all_existing(aController, aElement) { + aElement.focus(); + EventUtils.synthesizeKey("a", { accelKey: true }, aController.window); + aElement.focus(); + EventUtils.synthesizeKey("VK_DELETE", {}, aController.window); +} diff --git a/comm/mail/test/browser/shared-modules/MockObjectHelpers.jsm b/comm/mail/test/browser/shared-modules/MockObjectHelpers.jsm new file mode 100644 index 0000000000..3b4ed91e53 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/MockObjectHelpers.jsm @@ -0,0 +1,161 @@ +/* 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 EXPORTED_SYMBOLS = ["MockObjectReplacer", "MockObjectRegisterer"]; + +var Cm = Components.manager; + +function MockObjectRegisterer(aContractID, aCID, aComponent) { + this._contractID = aContractID; + this._cid = Components.ID("{" + aCID + "}"); + this._component = aComponent; +} + +MockObjectRegisterer.prototype = { + register() { + let providedConstructor = this._component; + this._mockFactory = { + createInstance(aIid) { + return new providedConstructor().QueryInterface(aIid); + }, + }; + + let componentRegistrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); + + componentRegistrar.registerFactory( + this._cid, + "", + this._contractID, + this._mockFactory + ); + }, + + unregister() { + let componentRegistrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); + + componentRegistrar.unregisterFactory(this._cid, this._mockFactory); + }, +}; + +/** + * Allows registering a mock XPCOM component, that temporarily replaces the + * original one when an object implementing a given ContractID is requested + * using createInstance. + * + * @param aContractID + * The ContractID of the component to replace, for example + * "@mozilla.org/filepicker;1". + * + * @param aReplacementCtor + * The constructor function for the JavaScript object that will be + * created every time createInstance is called. This object must + * implement QueryInterface and provide the XPCOM interfaces required by + * the specified ContractID (for example + * Ci.nsIFilePicker). + */ + +function MockObjectReplacer(aContractID, aReplacementCtor) { + this._contractID = aContractID; + this._replacementCtor = aReplacementCtor; + this._cid = null; +} + +MockObjectReplacer.prototype = { + /** + * Replaces the current factory with one that returns a new mock object. + * + * After register() has been called, it is mandatory to call unregister() to + * restore the original component. Usually, you should use a try-catch block + * to ensure that unregister() is called. + */ + register() { + if (this._cid) { + throw Error("Invalid object state when calling register()"); + } + + // Define a factory that creates a new object using the given constructor. + var providedConstructor = this._replacementCtor; + this._mockFactory = { + createInstance(aIid) { + return new providedConstructor().QueryInterface(aIid); + }, + }; + + var retVal = swapFactoryRegistration( + this._cid, + this._originalCID, + this._contractID, + this._mockFactory + ); + if ("error" in retVal) { + throw new Error("ERROR: " + retVal.error); + } else { + this._cid = retVal.cid; + this._originalCID = retVal.originalCID; + } + }, + + /** + * Restores the original factory. + */ + unregister() { + if (!this._cid) { + throw Error("Invalid object state when calling unregister()"); + } + + // Free references to the mock factory. + swapFactoryRegistration( + this._cid, + this._originalCID, + this._contractID, + this._mockFactory + ); + + // Allow registering a mock factory again later. + this._cid = null; + this._originalCID = null; + this._mockFactory = null; + }, + + // --- Private methods and properties --- + + /** + * The CID under which the mock contractID was registered. + */ + _cid: null, + + /** + * The nsIFactory that was automatically generated by this object. + */ + _mockFactory: null, +}; + +/** + * Swiped from mozilla/testing/mochitest/tests/SimpleTest/specialpowersAPI.js + */ +function swapFactoryRegistration(CID, originalCID, contractID, newFactory) { + let componentRegistrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); + + if (originalCID == null) { + if (contractID != null) { + originalCID = componentRegistrar.contractIDToCID(contractID); + void Cm.getClassObject(Cc[contractID], Ci.nsIFactory); + } else { + return { + error: "trying to register a new contract ID: Missing contractID", + }; + } + CID = Services.uuid.generateUUID(); + + componentRegistrar.registerFactory(CID, "", contractID, newFactory); + } else { + componentRegistrar.unregisterFactory(CID, newFactory); + // Restore the original factory. + componentRegistrar.registerFactory(originalCID, "", contractID, null); + } + + return { cid: CID, originalCID }; +} diff --git a/comm/mail/test/browser/shared-modules/MouseEventHelpers.jsm b/comm/mail/test/browser/shared-modules/MouseEventHelpers.jsm new file mode 100644 index 0000000000..cd0f9a09d4 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/MouseEventHelpers.jsm @@ -0,0 +1,226 @@ +/* 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 EXPORTED_SYMBOLS = [ + "drag_n_drop_element", + "synthesize_drag_start", + "synthesize_drag_over", + "synthesize_drag_end", + "synthesize_drop", +]; + +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); + +/** + * Execute a drag and drop session. + * + * @param {XULElement} aDragObject + * the element from which the drag session should be started. + * @param {} aDragWindow + * the window the aDragObject is in + * @param {XULElement} aDropObject + * the element at which the drag session should be ended. + * @param {} aDropWindow + * the window the aDropObject is in + * @param {} aRelDropX + * the relative x-position the element is dropped over the aDropObject + * in percent of the aDropObject width + * @param {} aRelDropY + * the relative y-position the element is dropped over the aDropObject + * in percent of the aDropObject height + * @param {XULElement} aListener + * the element who's drop target should be captured and returned. + */ +function drag_n_drop_element( + aDragObject, + aDragWindow, + aDropObject, + aDropWindow, + aRelDropX, + aRelDropY, + aListener +) { + let dt = synthesize_drag_start(aDragWindow, aDragObject, aListener); + Assert.ok(dt, "Drag data transfer was undefined"); + + synthesize_drag_over(aDropWindow, aDropObject, dt); + + let dropRect = aDropObject.getBoundingClientRect(); + synthesize_drop(aDropWindow, aDropObject, dt, { + screenX: aDropObject.screenX + dropRect.width * aRelDropX, + screenY: aDropObject.screenY + dropRect.height * aRelDropY, + }); +} + +/** + * Starts a drag new session. + * + * @param {} aWindow + * @param {XULElement} aDispatcher + * the element from which the drag session should be started. + * @param {XULElement} aListener + * the element who's drop target should be captured and returned. + * @returns {nsIDataTransfer} + * returns the DataTransfer Object of captured by aListener. + */ +function synthesize_drag_start(aWindow, aDispatcher, aListener) { + let dt; + + let trapDrag = function (event) { + if (!event.dataTransfer) { + throw new Error("no DataTransfer"); + } + + dt = event.dataTransfer; + + event.preventDefault(); + }; + + aListener.addEventListener("dragstart", trapDrag, true); + + EventUtils.synthesizeMouse(aDispatcher, 5, 5, { type: "mousedown" }, aWindow); + EventUtils.synthesizeMouse( + aDispatcher, + 5, + 10, + { type: "mousemove" }, + aWindow + ); + EventUtils.synthesizeMouse( + aDispatcher, + 5, + 15, + { type: "mousemove" }, + aWindow + ); + + aListener.removeEventListener("dragstart", trapDrag, true); + + return dt; +} + +/** + * Synthesizes a drag over event. + * + * @param {} aWindow + * @param {XULElement} aDispatcher + * the element from which the drag session should be started. + * @param {nsIDataTransfer} aDt + * the DataTransfer Object of captured by listener. + * @param {} aArgs + * arguments passed to the mouse event. + */ +function synthesize_drag_over(aWindow, aDispatcher, aDt, aArgs) { + _synthesizeDragEvent("dragover", aWindow, aDispatcher, aDt, aArgs); +} + +/** + * Synthesizes a drag end event. + * + * @param {} aWindow + * @param {XULElement} aDispatcher + * the element from which the drag session should be started. + * @param {nsIDataTransfer} aDt + * the DataTransfer Object of captured by listener. + * @param {} aArgs + * arguments passed to the mouse event. + */ +function synthesize_drag_end(aWindow, aDispatcher, aListener, aDt, aArgs) { + _synthesizeDragEvent("dragend", aWindow, aListener, aDt, aArgs); + + // Ensure drag has ended. + EventUtils.synthesizeMouse(aDispatcher, 5, 5, { type: "mousemove" }, aWindow); + EventUtils.synthesizeMouse( + aDispatcher, + 5, + 10, + { type: "mousemove" }, + aWindow + ); + EventUtils.synthesizeMouse(aDispatcher, 5, 5, { type: "mouseup" }, aWindow); +} + +/** + * Synthesizes a drop event. + * + * @param {} aWindow + * @param {XULElement} aDispatcher + * the element from which the drag session should be started. + * @param {nsIDataTransfer} aDt + * the DataTransfer Object of captured by listener. + * @param {} aArgs + * arguments passed to the mouse event. + */ +function synthesize_drop(aWindow, aDispatcher, aDt, aArgs) { + _synthesizeDragEvent("drop", aWindow, aDispatcher, aDt, aArgs); + + // Ensure drag has ended. + EventUtils.synthesizeMouse(aDispatcher, 5, 5, { type: "mousemove" }, aWindow); + EventUtils.synthesizeMouse( + aDispatcher, + 5, + 10, + { type: "mousemove" }, + aWindow + ); + EventUtils.synthesizeMouse(aDispatcher, 5, 5, { type: "mouseup" }, aWindow); +} + +/** + * Private function: Synthesizes a specified drag event. + * + * @param {} aType + * the type of the drag event to be synthesiyzed. + * @param {} aWindow + * @param {XULElement} aDispatcher + * the element from which the drag session should be started. + * @param {nsIDataTransfer} aDt + * the DataTransfer Object of captured by listener. + * @param {} aArgs + * arguments passed to the mouse event. + */ +function _synthesizeDragEvent(aType, aWindow, aDispatcher, aDt, aArgs) { + let screenX; + if (aArgs && "screenX" in aArgs) { + screenX = aArgs.screenX; + } else { + screenX = aDispatcher.screenX; + } + + let screenY; + if (aArgs && "screenY" in aArgs) { + screenY = aArgs.screenY; + } else { + screenY = aDispatcher.screenY; + } + + let event = aWindow.document.createEvent("DragEvent"); + event.initDragEvent( + aType, + true, + true, + aWindow, + 0, + screenX, + screenY, + 0, + 0, + false, + false, + false, + false, + 0, + null, + aDt + ); + aDispatcher.dispatchEvent(event); +} diff --git a/comm/mail/test/browser/shared-modules/NNTPHelpers.jsm b/comm/mail/test/browser/shared-modules/NNTPHelpers.jsm new file mode 100644 index 0000000000..71c785c02c --- /dev/null +++ b/comm/mail/test/browser/shared-modules/NNTPHelpers.jsm @@ -0,0 +1,123 @@ +/* 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 EXPORTED_SYMBOLS = [ + "setupNNTPDaemon", + "NNTP_PORT", + "setupLocalServer", + "startupNNTPServer", + "shutdownNNTPServer", +]; + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); +var { NewsArticle, NNTP_RFC977_handler, NntpDaemon } = ChromeUtils.import( + "resource://testing-common/mailnews/Nntpd.jsm" +); +var { nsMailServer } = ChromeUtils.import( + "resource://testing-common/mailnews/Maild.jsm" +); + +var kSimpleNewsArticle = + "From: John Doe <john.doe@example.com>\n" + + "Date: Sat, 24 Mar 1990 10:59:24 -0500\n" + + "Newsgroups: test.subscribe.simple\n" + + "Subject: H2G2 -- What does it mean?\n" + + "Message-ID: <TSS1@nntp.invalid>\n" + + "\n" + + "What does the acronym H2G2 stand for? I've seen it before...\n"; + +// The groups to set up on the fake server. +// It is an array of tuples, where the first element is the group name and the +// second element is whether or not we should subscribe to it. +var groups = [ + ["test.empty", false], + ["test.subscribe.empty", true], + ["test.subscribe.simple", true], + ["test.filter", true], +]; + +// Sets up the NNTP daemon object for use in fake server +function setupNNTPDaemon() { + var daemon = new NntpDaemon(); + + groups.forEach(function (element) { + daemon.addGroup(element[0]); + }); + + var article = new NewsArticle(kSimpleNewsArticle); + daemon.addArticleToGroup(article, "test.subscribe.simple", 1); + + return daemon; +} + +// Startup server +function startupNNTPServer(daemon, port) { + var handler = NNTP_RFC977_handler; + + function createHandler(daemon) { + return new handler(daemon); + } + + var server = new nsMailServer(createHandler, daemon); + server.start(port); + return server; +} + +// Shutdown server +function shutdownNNTPServer(server) { + server.stop(); +} + +// Enable strict threading +Services.prefs.setBoolPref("mail.strict_threading", true); + +// Make sure we don't try to use a protected port. I like adding 1024 to the +// default port when doing so... +var NNTP_PORT = 1024 + 119; + +var _server = null; + +function subscribeServer(incomingServer) { + // Subscribe to newsgroups + incomingServer.QueryInterface(Ci.nsINntpIncomingServer); + groups.forEach(function (element) { + if (element[1]) { + incomingServer.subscribeToNewsgroup(element[0]); + } + }); + // Only allow one connection + incomingServer.maximumConnectionsNumber = 1; +} + +// Sets up the client-side portion of fakeserver +function setupLocalServer(port) { + if (_server != null) { + return _server; + } + + var server = MailServices.accounts.createIncomingServer( + null, + "localhost", + "nntp" + ); + server.port = port; + server.valid = false; + + var account = MailServices.accounts.createAccount(); + account.incomingServer = server; + server.valid = true; + // hack to cause an account loaded notification now the server is valid + // (see also Bug 903804) + account.incomingServer = account.incomingServer; // eslint-disable-line no-self-assign + + subscribeServer(server); + + _server = server; + + return server; +} diff --git a/comm/mail/test/browser/shared-modules/NewMailAccountHelpers.jsm b/comm/mail/test/browser/shared-modules/NewMailAccountHelpers.jsm new file mode 100644 index 0000000000..e9992fa344 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/NewMailAccountHelpers.jsm @@ -0,0 +1,25 @@ +/* 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 EXPORTED_SYMBOLS = ["remove_email_account"]; + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +/** + * Remove an account with the address from the current profile. + * + * @param {string} address - The email address to try to remove. + */ +function remove_email_account(address) { + for (let account of MailServices.accounts.accounts) { + if (account.defaultIdentity && account.defaultIdentity.email == address) { + MailServices.accounts.removeAccount(account); + break; + } + } +} diff --git a/comm/mail/test/browser/shared-modules/NotificationBoxHelpers.jsm b/comm/mail/test/browser/shared-modules/NotificationBoxHelpers.jsm new file mode 100644 index 0000000000..14a853e001 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/NotificationBoxHelpers.jsm @@ -0,0 +1,219 @@ +/* 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 EXPORTED_SYMBOLS = [ + "check_notification_displayed", + "assert_notification_displayed", + "close_notification", + "wait_for_notification_to_stop", + "wait_for_notification_to_show", + "get_notification_button", + "get_notification", +]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +/** + * A helper function for determining whether or not a notification with + * a particular value is being displayed. + * + * @param aWindow the window to check + * @param aBoxId the id of the notification box + * @param aValue the value of the notification to look for + * @param aNotification an optional out parameter: object that will pass the + * notification element out of this function in its + * 'notification' property + * + * @returns True/false depending on the state of the notification. + */ +function check_notification_displayed(aWindow, aBoxId, aValue, aNotification) { + let nb = aWindow.document.getElementById(aBoxId); + if (!nb) { + throw new Error("Couldn't find a notification box for id=" + aBoxId); + } + + if (nb.querySelector(".notificationbox-stack")) { + let box = nb.querySelector(".notificationbox-stack")._notificationBox; + let notification = box.getNotificationWithValue(aValue); + if (aNotification) { + aNotification.notification = notification; + } + return notification != null; + } + + return false; +} + +/** + * A helper function ensuring whether or not a notification with + * a particular value is being displayed. Throws if the state is + * not the expected one. + * + * @param aWindow the window to check + * @param aBoxId the id of the notification box + * @param aValue the value of the notification to look for + * @param aDisplayed true if the notification should be displayed, false + * otherwise + * @returns the notification if we're asserting that the notification is + * displayed, and it actually shows up. Throws otherwise. + */ +function assert_notification_displayed(aWindow, aBoxId, aValue, aDisplayed) { + let notification = {}; + let hasNotification = check_notification_displayed( + aWindow, + aBoxId, + aValue, + notification + ); + if (hasNotification != aDisplayed) { + throw new Error( + "Expected the notification with value " + + aValue + + " to " + + (aDisplayed ? "be shown" : "not be shown") + ); + } + + return notification.notification; +} + +/** + * A helper function for closing a notification if one is currently displayed + * in the window. + * + * @param aWindow the window with the notification + * @param aBoxId the id of the notification box + * @param aValue the value of the notification to close + */ +function close_notification(aWindow, aBoxId, aValue) { + let nb = aWindow.document.getElementById(aBoxId); + if (!nb) { + throw new Error("Couldn't find a notification box for id=" + aBoxId); + } + + let box = nb.querySelector(".notificationbox-stack")._notificationBox; + let notification = box.getNotificationWithValue(aValue); + if (notification) { + notification.close(); + } +} + +/** + * A helper function that waits for a notification with value aValue + * to stop displaying in the window. + * + * @param aWindow the window with the notification + * @param aBoxId the id of the notification box + * @param aValue the value of the notification to wait to stop + */ +function wait_for_notification_to_stop(aWindow, aBoxId, aValue) { + let nb = aWindow.document.getElementById(aBoxId); + if (!nb) { + throw new Error("Couldn't find a notification box for id=" + aBoxId); + } + + let box = nb.querySelector(".notificationbox-stack")._notificationBox; + utils.waitFor( + () => !box.getNotificationWithValue(aValue), + "Timed out waiting for notification with value " + aValue + " to stop." + ); +} + +/** + * A helper function that waits for a notification with value aValue + * to show in the window. + * + * @param aWindow the window that we want the notification to appear in + * @param aBoxId the id of the notification box + * @param aValue the value of the notification to wait for + */ +function wait_for_notification_to_show(aWindow, aBoxId, aValue) { + let nb = aWindow.document.getElementById(aBoxId); + if (!nb) { + throw new Error("Couldn't find a notification box for id=" + aBoxId); + } + + function nbReady() { + if (nb.querySelector(".notificationbox-stack")) { + let box = nb.querySelector(".notificationbox-stack")._notificationBox; + return box.getNotificationWithValue(aValue) != null && !box._animating; + } + return false; + } + utils.waitFor( + nbReady, + "Timed out waiting for notification with value " + aValue + " to show." + ); +} + +/** + * Return the notification element based on the container ID and the Value type. + * + * @param {Window} win - The window that we want the notification to appear in. + * @param {string} id - The id of the notification box. + * @param {string} val - The value of the notification to fetch. + * @returns {?Element} - The notification element if found. + */ +function get_notification(win, id, val) { + let nb = win.document.getElementById(id); + if (!nb) { + throw new Error("Couldn't find a notification box for id=" + id); + } + + if (nb.querySelector(".notificationbox-stack")) { + let box = nb.querySelector(".notificationbox-stack")._notificationBox; + return box.getNotificationWithValue(val); + } + + return null; +} + +/** + * Gets a button in a notification, as those do not have IDs. + * + * @param aWindow The window that has the notification. + * @param aBoxId The id of the notification box. + * @param aValue The value of the notification to find. + * @param aMatch Attributes of the button to find. An object with key:value + * pairs, similar to click_menus_in_sequence(). + */ +function get_notification_button(aWindow, aBoxId, aValue, aMatch) { + let notification = get_notification(aWindow, aBoxId, aValue); + let buttons = notification.buttonContainer.querySelectorAll( + "button, toolbarbutton" + ); + for (let button of buttons) { + let matchedAll = true; + for (let name in aMatch) { + let value = aMatch[name]; + let matched = false; + if (name == "popup") { + if (button.getAttribute("type") == "menu") { + // The button contains a menupopup as the first child. + matched = button.querySelector("menupopup#" + value); + } else { + // The "popup" attribute is not on the button itself but in its + // buttonInfo member. + matched = "buttonInfo" in button && button.buttonInfo.popup == value; + } + } else if ( + button.hasAttribute(name) && + button.getAttribute(name) == value + ) { + matched = true; + } + if (!matched) { + matchedAll = false; + break; + } + } + if (matchedAll) { + return button; + } + } + + throw new Error("Couldn't find the requested button on a notification"); +} diff --git a/comm/mail/test/browser/shared-modules/OpenPGPTestUtils.jsm b/comm/mail/test/browser/shared-modules/OpenPGPTestUtils.jsm new file mode 100644 index 0000000000..5913778590 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/OpenPGPTestUtils.jsm @@ -0,0 +1,329 @@ +/* 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 EXPORTED_SYMBOLS = ["OpenPGPTestUtils"]; + +const { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +const { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); +const EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +const { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); + +const lazy = {}; + +XPCOMUtils.defineLazyModuleGetters(lazy, { + OpenPGPAlias: "chrome://openpgp/content/modules/OpenPGPAlias.jsm", + EnigmailCore: "chrome://openpgp/content/modules/core.jsm", + EnigmailFuncs: "chrome://openpgp/content/modules/funcs.jsm", + EnigmailKeyRing: "chrome://openpgp/content/modules/keyRing.jsm", + MailStringUtils: "resource:///modules/MailStringUtils.jsm", + RNP: "chrome://openpgp/content/modules/RNP.jsm", + PgpSqliteDb2: "chrome://openpgp/content/modules/sqliteDb.jsm", +}); + +const OpenPGPTestUtils = { + ACCEPTANCE_PERSONAL: "personal", + ACCEPTANCE_REJECTED: "rejected", + ACCEPTANCE_UNVERIFIED: "unverified", + ACCEPTANCE_VERIFIED: "verified", + ACCEPTANCE_UNDECIDED: "undecided", + ALICE_KEY_ID: "F231550C4F47E38E", + BOB_KEY_ID: "FBFCC82A015E7330", + CAROL_KEY_ID: "3099FF1238852B9F", + + /** + * Given a compose message window, clicks on the "Digitally Sign This Message" + * menu item. + */ + async toggleMessageSigning(win) { + return clickToolbarButtonMenuItem(win, "#button-encryption-options", [ + "#menu_securitySign_Toolbar", + ]); + }, + + /** + * Given a compose message window, clicks on the "Encrypt Subject" + * menu item. + */ + async toggleMessageEncryptSubject(win) { + return clickToolbarButtonMenuItem(win, "#button-encryption-options", [ + "#menu_securityEncryptSubject_Toolbar", + ]); + }, + + /** + * Given a compose message window, clicks on the "Attach My Public Key" + * menu item. + */ + async toggleMessageKeyAttachment(win) { + return clickToolbarButtonMenuItem(win, "#button-attach", [ + "#button-attachPopup_attachPublicKey", + ]); + }, + + /** + * Given a compose message window, clicks on the "Require Encryption" + * menu item. + */ + async toggleMessageEncryption(win) { + // Note: doing it through #menu_securityEncryptRequire_Menubar won't work on + // mac since the native menu bar can't be clicked. + // Use the toolbar button to click Require encryption. + await clickToolbarButtonMenuItem(win, "#button-encryption-options", [ + "#menu_securityEncrypt_Toolbar", + ]); + }, + + /** + * For xpcshell-tests OpenPGP is not initialized automatically. This method + * should be called at the start of testing. + */ + async initOpenPGP() { + Assert.ok(await lazy.RNP.init(), "librnp did load"); + Assert.ok(await lazy.EnigmailCore.getService({}), "EnigmailCore did load"); + lazy.EnigmailKeyRing.init(); + await lazy.OpenPGPAlias.load(); + }, + + /** + * Tests whether the signed icon's "src" attribute matches the provided state. + * + * @param {HTMLDocument} doc - The document of the message window. + * @param {"ok"|"unknown"|"verified"|"unverified"|"mismatch"} state - The + * state to test for. + * @returns {boolean} + */ + hasSignedIconState(doc, state) { + return !!doc.querySelector(`#signedHdrIcon[src*=message-signed-${state}]`); + }, + + /** + * Checks that the signed icon is hidden. + * + * @param {HTMLDocument} doc - The document of the message window. + * @returns {boolean} + */ + hasNoSignedIconState(doc) { + return !!doc.querySelector(`#signedHdrIcon[hidden]`); + }, + + /** + * Checks that the encrypted icon is hidden. + * + * @param {HTMLDocument} doc - The document of the message window. + * @returns {boolean} + */ + hasNoEncryptedIconState(doc) { + return !!doc.querySelector(`#encryptedHdrIcon[hidden]`); + }, + + /** + * Tests whether the encrypted icon's "src" attribute matches the provided + * state value. + * + * @param {HTMLDocument} doc - The document of the message window. + * @param {"ok"|"notok"} state - The state to test for. + * @returns {boolean} + */ + hasEncryptedIconState(doc, state) { + return !!doc.querySelector( + `#encryptedHdrIcon[src*=message-encrypted-${state}]` + ); + }, + + /** + * Imports a public key into the keyring while also updating its acceptance. + * + * @param {nsIWindow} parent - The parent window. + * @param {nsIFile} file - A valid file containing a public OpenPGP key. + * @param {string} [acceptance] - The acceptance setting for the key. + * @returns {string[]} - List of imported key ids. + */ + async importPublicKey( + parent, + file, + acceptance = OpenPGPTestUtils.ACCEPTANCE_VERIFIED + ) { + let ids = await OpenPGPTestUtils.importKey(parent, file, false); + if (!ids.length) { + throw new Error(`No public key imported from ${file.leafName}`); + } + return OpenPGPTestUtils.updateKeyIdAcceptance(ids, acceptance); + }, + + /** + * Imports a private key into the keyring while also updating its acceptance. + * + * @param {nsIWindow} parent - The parent window. + * @param {nsIFile} file - A valid file containing a private OpenPGP key. + * @param {string} [acceptance] - The acceptance setting for the key. + * @param {string} [passphrase] - The passphrase string that is required + * for unlocking the imported private key, or null, if no passphrase + * is necessary. The existing passphrase protection is kept. + * @param {boolean} [keepPassphrase] - true for keeping the existing + * passphrase. False for removing the existing passphrase and to + * set the automatic protection. If parameter passphrase is null + * then parameter keepPassphrase is ignored. + * @returns {string[]} - List of imported key ids. + */ + async importPrivateKey( + parent, + file, + acceptance = OpenPGPTestUtils.ACCEPTANCE_PERSONAL, + passphrase = null, + keepPassphrase = false + ) { + let data = await IOUtils.read(file.path); + let pgpBlock = lazy.MailStringUtils.uint8ArrayToByteString(data); + + function localPassphraseProvider(win, promptString, resultFlags) { + resultFlags.canceled = false; + return passphrase; + } + + if (passphrase != null && keepPassphrase == undefined) { + throw new Error( + "must provide true of false for parameter keepPassphrase" + ); + } + + let result = await lazy.RNP.importSecKeyBlockImpl( + parent, + localPassphraseProvider, + passphrase != null && keepPassphrase, + pgpBlock, + false, + [] + ); + + if (!result || result.exitCode !== 0) { + throw new Error( + `EnigmailKeyRing.importKey failed with result "${result.errorMsg}"!` + ); + } + if (!result.importedKeys || !result.importedKeys.length) { + throw new Error(`No private key imported from ${file.leafName}`); + } + + lazy.EnigmailKeyRing.updateKeys(result.importedKeys); + lazy.EnigmailKeyRing.clearCache(); + return OpenPGPTestUtils.updateKeyIdAcceptance( + result.importedKeys.slice(), + acceptance + ); + }, + + /** + * Imports a key into the keyring. + * + * @param {nsIWindow} parent - The parent window. + * @param {nsIFile} file - A valid file containing an OpenPGP key. + * @param {boolean} [isBinary] - false for ASCII armored files + * @returns {Promise<string[]>} - A list of ids for the key(s) imported. + */ + async importKey(parent, file, isBinary) { + let data = await IOUtils.read(file.path); + let txt = lazy.MailStringUtils.uint8ArrayToByteString(data); + let errorObj = {}; + let fingerPrintObj = {}; + + let result = lazy.EnigmailKeyRing.importKey( + parent, + false, + txt, + isBinary, + null, + errorObj, + fingerPrintObj, + false, + [], + false + ); + + if (result !== 0) { + console.debug( + `EnigmailKeyRing.importKey failed with result "${result}"!` + ); + return []; + } + return fingerPrintObj.value.slice(); + }, + + /** + * Updates the acceptance value of the provided key(s) in the database. + * + * @param {string|string[]} id - The id or list of ids to update. + * @param {string} acceptance - The new acceptance level for the key id. + * @returns {string[]} - A list of the key ids processed. + */ + async updateKeyIdAcceptance(id, acceptance) { + let ids = Array.isArray(id) ? id : [id]; + for (let id of ids) { + let key = lazy.EnigmailKeyRing.getKeyById(id); + let email = lazy.EnigmailFuncs.getEmailFromUserID(key.userId); + await lazy.PgpSqliteDb2.updateAcceptance(key.fpr, [email], acceptance); + } + lazy.EnigmailKeyRing.clearCache(); + return ids.slice(); + }, + + getProtectedKeysCount() { + return lazy.RNP.getProtectedKeysCount(); + }, + + /** + * Removes a key by its id, clearing its acceptance and refreshing the + * cache. + * + * @param {string|string[]} id - The id or list of ids to remove. + * @param {boolean} [deleteSecret=false] - If true, secret keys will be removed too. + */ + async removeKeyById(id, deleteSecret = false) { + let ids = Array.isArray(id) ? id : [id]; + for (let id of ids) { + let key = lazy.EnigmailKeyRing.getKeyById(id); + await lazy.RNP.deleteKey(key.fpr, deleteSecret); + await lazy.PgpSqliteDb2.deleteAcceptance(key.fpr); + } + lazy.EnigmailKeyRing.clearCache(); + }, +}; + +/** + * Click a toolbar button to make it show the dropdown. Then click one of + * the menuitems in that popup. + */ +async function clickToolbarButtonMenuItem( + win, + buttonSelector, + menuitemSelectors +) { + let menupopup = win.document.querySelector(`${buttonSelector} > menupopup`); + let popupshown = BrowserTestUtils.waitForEvent(menupopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter( + win.document.querySelector(`${buttonSelector} > dropmarker`), + {}, + win + ); + await popupshown; + + if (menuitemSelectors.length > 1) { + let submenuSelector = menuitemSelectors.shift(); + menupopup.querySelector(submenuSelector).openMenu(true); + } + + let popuphidden = BrowserTestUtils.waitForEvent(menupopup, "popuphidden"); + menupopup.activateItem(win.document.querySelector(menuitemSelectors[0])); + await popuphidden; +} diff --git a/comm/mail/test/browser/shared-modules/PrefTabHelpers.jsm b/comm/mail/test/browser/shared-modules/PrefTabHelpers.jsm new file mode 100644 index 0000000000..9f56fd2c25 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/PrefTabHelpers.jsm @@ -0,0 +1,53 @@ +/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +/* + * Helpers to deal with the preferences tab. + */ + +"use strict"; + +const EXPORTED_SYMBOLS = ["close_pref_tab", "open_pref_tab"]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +var fdh = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var cth = ChromeUtils.import( + "resource://testing-common/mozmill/ContentTabHelpers.jsm" +); + +/** + * Open the preferences tab with the given pane displayed. The pane needs to + * be one of the prefpane ids in mail/components/preferences/preferences.xhtml. + * + * @param aPaneID The ID of the pref pane to display (see + * mail/components/preferences/preferences.xhtml for valid IDs.) + */ +function open_pref_tab(aPaneID, aScrollTo) { + let tab = cth.open_content_tab_with_click( + function () { + fdh.mc.window.openOptionsDialog(aPaneID, aScrollTo); + }, + "about:preferences", + fdh.mc, + "preferencesTab" + ); + utils.waitFor( + () => tab.browser.contentWindow.gLastCategory.category == aPaneID, + "Timed out waiting for prefpane " + aPaneID + " to load." + ); + return tab; +} + +/** + * Close the preferences tab. + * + * @param aTab The content tab to close. + */ +function close_pref_tab(aTab) { + fdh.mc.window.document.getElementById("tabmail").closeTab(aTab); +} diff --git a/comm/mail/test/browser/shared-modules/PromptHelpers.jsm b/comm/mail/test/browser/shared-modules/PromptHelpers.jsm new file mode 100644 index 0000000000..ca3eaac3b0 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/PromptHelpers.jsm @@ -0,0 +1,271 @@ +/* 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 EXPORTED_SYMBOLS = [ + "gMockPromptService", + "gMockAuthPromptReg", + "gMockAuthPrompt", +]; + +var { MockObjectReplacer } = ChromeUtils.import( + "resource://testing-common/mozmill/MockObjectHelpers.jsm" +); + +var { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); + +var kMockPromptServiceName = "Mock Prompt Service"; +var kPromptServiceContractID = "@mozilla.org/prompter;1"; +var kPromptServiceName = "Prompt Service"; + +var gMockAuthPromptReg = new MockObjectReplacer( + "@mozilla.org/prompter;1", + MockAuthPromptFactoryConstructor +); + +function MockAuthPromptFactoryConstructor() { + return gMockAuthPromptFactory; +} + +var gMockAuthPromptFactory = { + QueryInterface: ChromeUtils.generateQI(["nsIPromptFactory"]), + getPrompt(aParent, aIID, aResult) { + return gMockAuthPrompt.QueryInterface(aIID); + }, +}; + +var gMockAuthPrompt = { + password: "", + + QueryInterface: ChromeUtils.generateQI(["nsIAuthPrompt"]), + + prompt(aTitle, aText, aRealm, aSave, aDefaultText) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + + promptUsernameAndPassword(aTitle, aText, aRealm, aSave, aUser, aPwd) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + + promptPassword(aTitle, aText, aRealm, aSave, aPwd) { + aPwd.value = this.password; + return true; + }, +}; + +var gMockPromptService = { + _registered: false, + QueryInterface: ChromeUtils.generateQI(["nsIPromptService"]), + _will_return: null, + _inout_value: null, + _promptState: null, + _origFactory: null, + _promptCb: null, + + alert(aParent, aDialogTitle, aText) { + this._promptState = { + method: "alert", + parent: aParent, + dialogTitle: aDialogTitle, + text: aText, + }; + }, + + confirm(aParent, aDialogTitle, aText) { + this._promptState = { + method: "confirm", + parent: aParent, + dialogTitle: aDialogTitle, + text: aText, + }; + + this.fireCb(); + + return this._will_return; + }, + + confirmCheck(aParent, aDialogTitle, aText) { + this._promptState = { + method: "confirmCheck", + parent: aParent, + dialogTitle: aDialogTitle, + text: aText, + }; + + this.fireCb(); + + return this._will_return; + }, + + confirmEx( + aParent, + aDialogTitle, + aText, + aButtonFlags, + aButton0Title, + aButton1Title, + aButton2Title, + aCheckMsg, + aCheckState + ) { + this._promptState = { + method: "confirmEx", + parent: aParent, + dialogTitle: aDialogTitle, + text: aText, + buttonFlags: aButtonFlags, + button0Title: aButton0Title, + button1Title: aButton1Title, + button2Title: aButton2Title, + checkMsg: aCheckMsg, + checkState: aCheckState, + }; + + this.fireCb(); + + return this._will_return; + }, + + prompt(aParent, aDialogTitle, aText, aValue, aCheckMsg, aCheckState) { + this._promptState = { + method: "prompt", + parent: aParent, + dialogTitle: aDialogTitle, + text: aText, + value: aValue, + checkMsg: aCheckMsg, + checkState: aCheckState, + }; + + this.fireCb(); + + if (this._inout_value != null) { + aValue.value = this._inout_value; + } + + return this._will_return; + }, + + // Other dialogs should probably be mocked here, including alert, + // alertCheck, etc. + // See: http://mxr.mozilla.org/mozilla-central/source/embedding/components/ + // windowwatcher/public/nsIPromptService.idl + + /* Sets the value that the alert, confirm, etc dialog will return to + * the caller. + */ + set returnValue(aReturn) { + this._will_return = aReturn; + }, + + set inoutValue(aValue) { + this._inout_value = aValue; + }, + + set onPromptCallback(aCb) { + this._promptCb = aCb; + }, + + promisePrompt() { + return new Promise(resolve => { + this.onPromptCallback = resolve; + }); + }, + + fireCb() { + if (typeof this._promptCb == "function") { + this._promptCb.call(); + } + }, + + /* Wipes out the prompt state and any return values. + */ + reset() { + this._will_return = null; + this._promptState = null; + this._promptCb = null; + this._inout_value = null; + }, + + /* Returns the prompt state if one was observed since registering + * the Mock Prompt Service. + */ + get promptState() { + return this._promptState; + }, + + CID: Components.ID("{404ebfa2-d8f4-4c94-8416-e65a55f9df5b}"), + + get registrar() { + delete this.registrar; + return (this.registrar = Components.manager.QueryInterface( + Ci.nsIComponentRegistrar + )); + }, + + /* Registers the Mock Prompt Service, and stores the original Prompt Service. + */ + register() { + if (!this.originalCID) { + void Components.manager.getClassObject( + Cc[kPromptServiceContractID], + Ci.nsIFactory + ); + + this.originalCID = this.registrar.contractIDToCID( + kPromptServiceContractID + ); + this.registrar.registerFactory( + this.CID, + kMockPromptServiceName, + kPromptServiceContractID, + gMockPromptServiceFactory + ); + this._resetServicesPrompt(); + } + }, + + /* Unregisters the Mock Prompt Service, and re-registers the original + * Prompt Service. + */ + unregister() { + if (this.originalCID) { + // Unregister the mock. + this.registrar.unregisterFactory(this.CID, gMockPromptServiceFactory); + + this.registrar.registerFactory( + this.originalCID, + kPromptServiceName, + kPromptServiceContractID, + null + ); + + delete this.originalCID; + this._resetServicesPrompt(); + } + }, + + _resetServicesPrompt() { + // eslint-disable-next-line mozilla/use-services + XPCOMUtils.defineLazyServiceGetter( + Services, + "prompt", + kPromptServiceContractID, + "nsIPromptService" + ); + }, +}; + +var gMockPromptServiceFactory = { + createInstance(aIID) { + if (!aIID.equals(Ci.nsIPromptService)) { + throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE); + } + + return gMockPromptService; + }, +}; diff --git a/comm/mail/test/browser/shared-modules/QuickFilterBarHelpers.jsm b/comm/mail/test/browser/shared-modules/QuickFilterBarHelpers.jsm new file mode 100644 index 0000000000..04dee48e09 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/QuickFilterBarHelpers.jsm @@ -0,0 +1,391 @@ +/* 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 EXPORTED_SYMBOLS = [ + "assert_quick_filter_button_enabled", + "assert_quick_filter_bar_visible", + "toggle_quick_filter_bar", + "assert_constraints_expressed", + "toggle_boolean_constraints", + "toggle_tag_constraints", + "toggle_tag_mode", + "assert_tag_constraints_visible", + "assert_tag_constraints_checked", + "toggle_text_constraints", + "assert_text_constraints_checked", + "set_filter_text", + "assert_filter_text", + "assert_results_label_count", + "clear_constraints", + "cleanup_qfb_button", +]; + +var { get_about_3pane, mc, wait_for_all_messages_to_load } = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); + +const { getState, storeState } = ChromeUtils.importESModule( + "resource:///modules/CustomizationState.mjs" +); + +const { getDefaultItemIdsForSpace } = ChromeUtils.importESModule( + "resource:///modules/CustomizableItems.sys.mjs" +); + +let about3Pane = get_about_3pane(); +about3Pane.quickFilterBar.deferredUpdateSearch = + about3Pane.quickFilterBar.updateSearch; + +/** + * Maps names to bar DOM ids to simplify checking. + */ +var nameToBarDomId = { + sticky: "qfb-sticky", + unread: "qfb-unread", + starred: "qfb-starred", + addrbook: "qfb-inaddrbook", + tags: "qfb-tags", + attachments: "qfb-attachment", +}; + +async function ensure_qfb_unified_toolbar_button() { + const document = mc.window.document; + + const state = getState(); + if (state.mail?.includes("quick-filter-bar")) { + return; + } + if (!state.mail) { + state.mail = getDefaultItemIdsForSpace("mail"); + if (state.mail.includes("quick-filter-bar")) { + return; + } + } + state.mail.push("quick-filter-bar"); + storeState(state); + await BrowserTestUtils.waitForMutationCondition( + document.getElementById("unifiedToolbarContent"), + { + subtree: true, + childList: true, + }, + () => + document.querySelector("#unifiedToolbarContent .quick-filter-bar button") + ); +} + +async function cleanup_qfb_button() { + const document = mc.window.document; + const state = getState(); + if (!state.mail?.includes("quick-filter-bar")) { + return; + } + state.mail = getDefaultItemIdsForSpace("mail"); + storeState(state); + await BrowserTestUtils.waitForMutationCondition( + document.getElementById("unifiedToolbarContent"), + { + subtree: true, + childList: true, + }, + () => !document.querySelector("#unifiedToolbarContent .quick-filter-bar") + ); +} + +async function assert_quick_filter_button_enabled(aEnabled) { + await ensure_qfb_unified_toolbar_button(); + if ( + mc.window.document.querySelector( + "#unifiedToolbarContent .quick-filter-bar button" + ).disabled == aEnabled + ) { + throw new Error( + "Quick filter bar button should be " + (aEnabled ? "enabled" : "disabled") + ); + } +} + +function assert_quick_filter_bar_visible(aVisible) { + let bar = about3Pane.document.getElementById("quick-filter-bar"); + if (aVisible) { + Assert.ok( + BrowserTestUtils.is_visible(bar), + "Quick filter bar should be visible" + ); + } else { + Assert.ok( + BrowserTestUtils.is_hidden(bar), + "Quick filter bar should be hidden" + ); + } +} + +/** + * Toggle the state of the message filter bar as if by a mouse click. + */ +async function toggle_quick_filter_bar() { + await ensure_qfb_unified_toolbar_button(); + EventUtils.synthesizeMouseAtCenter( + mc.window.document.querySelector( + "#unifiedToolbarContent .quick-filter-bar" + ), + { clickCount: 1 }, + mc.window + ); + wait_for_all_messages_to_load(); +} + +/** + * Assert that the state of the constraints visually expressed by the bar is + * consistent with the passed-in constraints. This method does not verify + * that the search constraints are in effect. Check that elsewhere. + */ +function assert_constraints_expressed(aConstraints) { + for (let name in nameToBarDomId) { + let domId = nameToBarDomId[name]; + let expectedValue = name in aConstraints ? aConstraints[name] : false; + let domNode = about3Pane.document.getElementById(domId); + Assert.equal( + domNode.pressed, + expectedValue, + name + "'s pressed state should be " + expectedValue + ); + } +} + +/** + * Toggle the given filter buttons by name (from nameToBarDomId); variable + * argument magic enabled. + */ +function toggle_boolean_constraints(...aArgs) { + aArgs.forEach(arg => + EventUtils.synthesizeMouseAtCenter( + about3Pane.document.getElementById(nameToBarDomId[arg]), + { clickCount: 1 }, + about3Pane + ) + ); + wait_for_all_messages_to_load(mc); +} + +/** + * Toggle the tag faceting buttons by tag key. Wait for messages after. + */ +function toggle_tag_constraints(...aArgs) { + aArgs.forEach(function (arg) { + let tagId = "qfb-tag-" + arg; + let button = about3Pane.document.getElementById(tagId); + button.scrollIntoView(); + EventUtils.synthesizeMouseAtCenter(button, { clickCount: 1 }, about3Pane); + }); + wait_for_all_messages_to_load(mc); +} + +/** + * Set the tag filtering mode. Wait for messages after. + */ +function toggle_tag_mode() { + let qbm = about3Pane.document.getElementById("qfb-boolean-mode"); + if (qbm.value === "AND") { + qbm.selectedIndex--; // = move to "OR"; + Assert.equal(qbm.value, "OR", "qfb-boolean-mode has wrong state"); + } else if (qbm.value === "OR") { + qbm.selectedIndex++; // = move to "AND"; + Assert.equal(qbm.value, "AND", "qfb-boolean-mode has wrong state"); + } else { + throw new Error("qfb-boolean-mode value=" + qbm.value); + } + wait_for_all_messages_to_load(mc); +} + +/** + * Verify that tag buttons exist for exactly the given set of tag keys in the + * provided variable argument list. Ordering is significant. + */ +function assert_tag_constraints_visible(...aArgs) { + // the stupid bar should be visible if any arguments are specified + let tagBar = get_about_3pane().document.getElementById( + "quickFilterBarTagsContainer" + ); + if (aArgs.length > 0) { + Assert.ok( + BrowserTestUtils.is_visible(tagBar), + "The tag bar should not be collapsed!" + ); + } + + let kids = tagBar.children; + let tagLength = kids.length - 1; // -1 for the qfb-boolean-mode widget + // this is bad error reporting in here for now. + if (tagLength != aArgs.length) { + throw new Error( + "Mismatch in expected tag count and actual. " + + "Expected " + + aArgs.length + + " actual " + + tagLength + ); + } + for (let iArg = 0; iArg < aArgs.length; iArg++) { + let nodeId = "qfb-tag-" + aArgs[iArg]; + if (nodeId != kids[iArg + 1].id) { + throw new Error( + "Mismatch at tag " + + iArg + + " expected " + + nodeId + + " but got " + + kids[iArg + 1].id + ); + } + } +} + +/** + * Verify that only the buttons corresponding to the provided tag keys are + * checked. + */ +function assert_tag_constraints_checked(...aArgs) { + let expected = {}; + for (let arg of aArgs) { + let nodeId = "qfb-tag-" + arg; + expected[nodeId] = true; + } + + let kids = mc.window.document.getElementById( + "quickFilterBarTagsContainer" + ).children; + for (let iNode = 0; iNode < kids.length; iNode++) { + let node = kids[iNode]; + if (node.pressed != node.id in expected) { + throw new Error( + "node " + + node.id + + " should " + + (node.id in expected ? "be " : "not be ") + + "checked." + ); + } + } +} + +var nameToTextDomId = { + sender: "qfb-qs-sender", + recipients: "qfb-qs-recipients", + subject: "qfb-qs-subject", + body: "qfb-qs-body", +}; + +function toggle_text_constraints(...aArgs) { + aArgs.forEach(arg => + EventUtils.synthesizeMouseAtCenter( + about3Pane.document.getElementById(nameToTextDomId[arg]), + { clickCount: 1 }, + about3Pane + ) + ); + wait_for_all_messages_to_load(mc); +} + +/** + * Assert that the text constraint buttons are checked. Variable-argument + * support where the arguments are one of sender/recipients/subject/body. + */ +function assert_text_constraints_checked(...aArgs) { + let expected = {}; + for (let arg of aArgs) { + let nodeId = nameToTextDomId[arg]; + expected[nodeId] = true; + } + + let kids = about3Pane.document.querySelectorAll( + "#quick-filter-bar-filter-text-bar button" + ); + for (let iNode = 0; iNode < kids.length; iNode++) { + let node = kids[iNode]; + if (node.tagName == "label") { + continue; + } + if (node.pressed != node.id in expected) { + throw new Error( + "node " + + node.id + + " should " + + (node.id in expected ? "be " : "not be ") + + "checked." + ); + } + } +} + +/** + * Set the text in the text filter box, trigger it like enter was pressed, then + * wait for all messages to load. + */ +function set_filter_text(aText) { + // We're not testing the reliability of the textbox widget; just poke our text + // in and trigger the command logic. + let textbox = about3Pane.document.getElementById("qfb-qs-textbox"); + textbox.value = aText; + textbox.doCommand(); + wait_for_all_messages_to_load(mc); +} + +function assert_filter_text(aText) { + let textbox = get_about_3pane().document.getElementById("qfb-qs-textbox"); + if (textbox.value != aText) { + throw new Error( + "Expected text filter value of '" + + aText + + "' but got '" + + textbox.value + + "'" + ); + } +} + +/** + * Assert that the results label is telling us there are aCount messages + * using the appropriate string. + */ +function assert_results_label_count(aCount) { + let resultsLabel = about3Pane.document.getElementById("qfb-results-label"); + let attributes = about3Pane.document.l10n.getAttributes(resultsLabel); + if (aCount == 0) { + Assert.deepEqual( + attributes, + { id: "quick-filter-bar-no-results", args: null }, + "results label should be displaying the no messages case" + ); + } else { + Assert.deepEqual( + attributes, + { id: "quick-filter-bar-results", args: { count: aCount } }, + `result count should show ${aCount}` + ); + } +} + +/** + * Clear active constraints via any means necessary; state cleanup for testing, + * not to be used as part of a test. Unlike normal clearing, this will kill + * the sticky bit. + * + * This is automatically called by the test teardown helper. + */ +function clear_constraints() { + about3Pane.quickFilterBar._testHelperResetFilterState(); +} diff --git a/comm/mail/test/browser/shared-modules/SearchWindowHelpers.jsm b/comm/mail/test/browser/shared-modules/SearchWindowHelpers.jsm new file mode 100644 index 0000000000..2eea0e17e7 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/SearchWindowHelpers.jsm @@ -0,0 +1,206 @@ +/* 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 EXPORTED_SYMBOLS = [ + "assert_messages_in_search_view", + "assert_search_window_folder_displayed", + "close_search_window", + "open_search_window", + "open_search_window_from_context_menu", + "select_click_search_row", + "select_shift_click_search_row", +]; + +var { get_about_3pane, mc, right_click_on_folder } = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var windowHelper = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +/** + * Open a search window using the accel-shift-f shortcut. + * + * @returns the controller for the search window + */ +function open_search_window() { + windowHelper.plan_for_new_window("mailnews:search"); + EventUtils.synthesizeKey("f", { shiftKey: true, accelKey: true }, mc.window); + return windowHelper.wait_for_new_window("mailnews:search"); +} + +/** + * Open a search window as if from the context menu. This needs the context menu + * to be already open. + * + * @param aFolder the folder to open the search window for + * @returns the controller for the search window + */ +async function open_search_window_from_context_menu(aFolder) { + let win = get_about_3pane(); + let context = win.document.getElementById("folderPaneContext"); + let item = win.document.getElementById("folderPaneContext-searchMessages"); + await right_click_on_folder(aFolder); + + windowHelper.plan_for_new_window("mailnews:search"); + context.activateItem(item); + return windowHelper.wait_for_new_window("mailnews:search"); +} + +/** + * Close a search window by calling window.close() on the controller. + */ +function close_search_window(aController) { + windowHelper.close_window(aController); +} + +/** + * Assert that the given folder is selected in the search window corresponding + * to the given controller. + */ +function assert_search_window_folder_displayed(aController, aFolder) { + let currentFolder = aController.window.gCurrentFolder; + Assert.equal( + currentFolder, + aFolder, + "The search window's selected folder should have been: " + + aFolder.prettyName + + ", but is actually: " + + currentFolder?.prettyName + ); +} + +/** + * Pretend we are clicking on a row with our mouse. + * + * @param {number} aViewIndex - The view index to click. + * @param {MozMillController} aController - The controller in whose context to + * do this. + * @returns {nsIMsgDBHdr} The message header selected. + */ +function select_click_search_row(aViewIndex, aController) { + if (aController == null) { + aController = mc; + } + + let tree = aController.window.document.getElementById("threadTree"); + tree.scrollToRow(aViewIndex); + let coords = tree.getCoordsForCellItem( + aViewIndex, + tree.columns.subjectCol, + "cell" + ); + let treeChildren = tree.lastElementChild; + EventUtils.synthesizeMouse( + treeChildren, + coords.x + coords.width / 2, + coords.y + coords.height / 2, + {}, + aController.window + ); + + return aController.window.gFolderDisplay.view.dbView.getMsgHdrAt(aViewIndex); +} + +/** + * Pretend we are clicking on a row with our mouse with the shift key pressed, + * adding all the messages between the shift pivot and the shift selected row. + * + * @param {number} aViewIndex - The view index to click. + * @param {MozMillController} aController The controller in whose context to + * do this. + * @returns {nsIMsgDBHdr[]} The message headers for all messages that are now + * selected. + */ +function select_shift_click_search_row(aViewIndex, aController) { + if (aController == null) { + aController = mc; + } + + let tree = aController.window.document.getElementById("threadTree"); + tree.scrollToRow(aViewIndex); + let coords = tree.getCoordsForCellItem( + aViewIndex, + tree.columns.subjectCol, + "cell" + ); + let treeChildren = tree.lastElementChild; + EventUtils.synthesizeMouse( + treeChildren, + coords.x + coords.width / 2, + coords.y + coords.height / 2, + { shiftKey: true }, + aController.window + ); + + utils.sleep(0); + return aController.window.gFolderDisplay.selectedMessages; +} + +/** + * Assert that the given synthetic message sets are present in the folder + * display. + * + * Verify that the messages in the provided SyntheticMessageSets are the only + * visible messages in the provided DBViewWrapper. + * + * @param {SyntheticMessageSet} aSynSets - Either a single SyntheticMessageSet + * or a list of them. + * @param {MozMillController} aController - The controller which we get the + * folderDisplay property from. + */ +function assert_messages_in_search_view(aSynSets, aController) { + if (aController == null) { + aController = mc; + } + if (!Array.isArray(aSynSets)) { + aSynSets = [aSynSets]; + } + + // Iterate over all the message sets, retrieving the message header. Use + // this to construct a URI to populate a dictionary mapping. + let synMessageURIs = {}; // map URI to message header + for (let messageSet of aSynSets) { + for (let msgHdr of messageSet.msgHdrs()) { + synMessageURIs[msgHdr.folder.getUriForMsg(msgHdr)] = msgHdr; + } + } + + // Iterate over the contents of the view, nulling out values in + // synMessageURIs for found messages, and exploding for missing ones. + let dbView = aController.window.gFolderDisplay.view.dbView; + let treeView = aController.window.gFolderDisplay.view.dbView.QueryInterface( + Ci.nsITreeView + ); + let rowCount = treeView.rowCount; + + for (let iViewIndex = 0; iViewIndex < rowCount; iViewIndex++) { + let msgHdr = dbView.getMsgHdrAt(iViewIndex); + let uri = msgHdr.folder.getUriForMsg(msgHdr); + Assert.ok( + uri in synMessageURIs, + "The view should show the message header" + msgHdr.messageKey + ); + delete synMessageURIs[uri]; + } + + // Iterate over our URI set and make sure every message was shown. + for (let uri in synMessageURIs) { + let msgHdr = synMessageURIs[uri]; + Assert.ok( + false, + "The view is should include the message header" + msgHdr.messageKey + ); + } +} diff --git a/comm/mail/test/browser/shared-modules/SubscribeWindowHelpers.jsm b/comm/mail/test/browser/shared-modules/SubscribeWindowHelpers.jsm new file mode 100644 index 0000000000..2f096479f0 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/SubscribeWindowHelpers.jsm @@ -0,0 +1,82 @@ +/* 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 EXPORTED_SYMBOLS = [ + "open_subscribe_window_from_context_menu", + "enter_text_in_search_box", + "check_newsgroup_displayed", +]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); +var { get_about_3pane, right_click_on_folder } = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var { input_value, delete_all_existing } = ChromeUtils.import( + "resource://testing-common/mozmill/KeyboardHelpers.jsm" +); +var { click_menus_in_sequence, plan_for_modal_dialog, wait_for_modal_dialog } = + ChromeUtils.import("resource://testing-common/mozmill/WindowHelpers.jsm"); + +/** + * Open a subscribe dialog from the context menu. + * + * @param aFolder the folder to open the subscribe dialog for + * @param aFunction Callback that will be invoked with a controller + * for the subscribe dialogue as parameter + */ +async function open_subscribe_window_from_context_menu(aFolder, aFunction) { + let win = get_about_3pane(); + + await right_click_on_folder(aFolder); + let callback = function (controller) { + // When the "stop button" is disabled, the panel is populated. + utils.waitFor( + () => controller.window.document.getElementById("stopButton").disabled + ); + aFunction(controller); + }; + plan_for_modal_dialog("mailnews:subscribe", callback); + await click_menus_in_sequence( + win.document.getElementById("folderPaneContext"), + [{ id: "folderPaneContext-subscribe" }] + ); + wait_for_modal_dialog("mailnews:subscribe"); +} + +/** + * Enter a string in the text box for the search value. + * + * @param swc A controller for a subscribe dialog + * @param text The text to enter + */ +function enter_text_in_search_box(swc, text) { + let textbox = swc.window.document.getElementById("namefield"); + delete_all_existing(swc, textbox); + input_value(swc, text, textbox); +} + +/** + * Check whether the given newsgroup is in the searchview. + * + * @param swc A controller for the subscribe window + * @param name Name of the newsgroup + * @returns {boolean} Result of the check + */ +function check_newsgroup_displayed(swc, name) { + let tree = swc.window.document.getElementById("searchTree"); + if (!tree.columns) { + // Maybe not yet available. + return false; + } + let treeview = tree.view; + let nameCol = tree.columns.getNamedColumn("nameColumn2"); + for (let i = 0; i < treeview.rowCount; i++) { + if (treeview.getCellText(i, nameCol) == name) { + return true; + } + } + return false; +} diff --git a/comm/mail/test/browser/shared-modules/ViewHelpers.jsm b/comm/mail/test/browser/shared-modules/ViewHelpers.jsm new file mode 100644 index 0000000000..33d39a8e07 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/ViewHelpers.jsm @@ -0,0 +1,85 @@ +/* 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/. */ + +/** Module to help debugging view wrapper issues. */ + +const EXPORTED_SYMBOLS = ["dump_view_contents", "dump_view_state"]; + +function dump_view_state(aViewWrapper, aDoNotDumpContents) { + if (aViewWrapper.dbView == null) { + dump("no nsIMsgDBView instance!\n"); + return; + } + if (!aDoNotDumpContents) { + dump_view_contents(aViewWrapper); + } + dump("View: " + aViewWrapper.dbView + "\n"); + dump( + " View Type: " + + _lookupValueNameInInterface( + aViewWrapper.dbView.viewType, + Ci.nsMsgViewType + ) + + " " + + "View Flags: " + + aViewWrapper.dbView.viewFlags + + "\n" + ); + dump( + " Sort Type: " + + _lookupValueNameInInterface( + aViewWrapper.dbView.sortType, + Ci.nsMsgViewSortType + ) + + " " + + "Sort Order: " + + _lookupValueNameInInterface( + aViewWrapper.dbView.sortOrder, + Ci.nsMsgViewSortOrder + ) + + "\n" + ); + dump(aViewWrapper.search.prettyString()); +} + +var WHITESPACE = " "; +var MSG_VIEW_FLAG_DUMMY = 0x20000000; +function dump_view_contents(aViewWrapper) { + let dbView = aViewWrapper.dbView; + let treeView = aViewWrapper.dbView.QueryInterface(Ci.nsITreeView); + let rowCount = treeView.rowCount; + + dump("********* Current View Contents\n"); + for (let iViewIndex = 0; iViewIndex < rowCount; iViewIndex++) { + let level = treeView.getLevel(iViewIndex); + let flags = dbView.getFlagsAt(iViewIndex); + let msgHdr = dbView.getMsgHdrAt(iViewIndex); + + let s = WHITESPACE.substr(0, level * 2); + if (treeView.isContainer(iViewIndex)) { + s += treeView.isContainerOpen(iViewIndex) ? "- " : "+ "; + } else { + s += ". "; + } + // s += treeView.getCellText(iViewIndex, ) + if (flags & MSG_VIEW_FLAG_DUMMY) { + s += "dummy: "; + } + s += dbView.cellTextForColumn(iViewIndex, "subject"); + s += " [" + msgHdr.folder.prettyName + "," + msgHdr.messageKey + "]"; + + dump(s + "\n"); + } + dump("********* end view contents\n"); +} + +function _lookupValueNameInInterface(aValue, aInterface) { + for (let key in aInterface) { + let value = aInterface[key]; + if (value == aValue) { + return key; + } + } + return "unknown: " + aValue; +} diff --git a/comm/mail/test/browser/shared-modules/WindowHelpers.jsm b/comm/mail/test/browser/shared-modules/WindowHelpers.jsm new file mode 100644 index 0000000000..9a8d16fbae --- /dev/null +++ b/comm/mail/test/browser/shared-modules/WindowHelpers.jsm @@ -0,0 +1,1018 @@ +/* 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 EXPORTED_SYMBOLS = [ + "click_menus_in_sequence", + "close_popup_sequence", + "click_through_appmenu", + "plan_for_new_window", + "wait_for_new_window", + "async_plan_for_new_window", + "plan_for_modal_dialog", + "wait_for_modal_dialog", + "plan_for_window_close", + "wait_for_window_close", + "close_window", + "wait_for_existing_window", + "wait_for_window_focused", + "wait_for_browser_load", + "wait_for_frame_load", + "resize_to", +]; + +var controller = ChromeUtils.import( + "resource://testing-common/mozmill/controller.jsm" +); +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); +var { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); +var { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm"); + +var EventUtils = ChromeUtils.import( + "resource://testing-common/mozmill/EventUtils.jsm" +); + +/** + * Timeout to use when waiting for the first window ever to load. This is + * long because we are basically waiting for the entire app startup process. + */ +var FIRST_WINDOW_EVER_TIMEOUT_MS = 30000; +/** + * Interval to check if the window has shown up for the first window ever to + * load. The check interval is longer because it's less likely the window + * is going to show up quickly and there is a cost to the check. + */ +var FIRST_WINDOW_CHECK_INTERVAL_MS = 300; + +/** + * Timeout for opening a window. + */ +var WINDOW_OPEN_TIMEOUT_MS = 10000; +/** + * Check interval for opening a window. + */ +var WINDOW_OPEN_CHECK_INTERVAL_MS = 100; + +/** + * Timeout for closing a window. + */ +var WINDOW_CLOSE_TIMEOUT_MS = 10000; +/** + * Check interval for closing a window. + */ +var WINDOW_CLOSE_CHECK_INTERVAL_MS = 100; + +/** + * Timeout for focusing a window. Only really an issue on linux. + */ +var WINDOW_FOCUS_TIMEOUT_MS = 10000; + +function getWindowTypeOrId(aWindowElem) { + let windowType = aWindowElem.getAttribute("windowtype"); + // Ignore types that start with "prompt:". This prefix gets added in + // toolkit/components/prompts/src/CommonDialog.jsm since bug 1388238. + if (windowType && !windowType.startsWith("prompt:")) { + return windowType; + } + + return aWindowElem.getAttribute("id"); +} + +/** + * Return the "windowtype" or "id" for the given app window if it is available. + * If not, return null. + */ +function getWindowTypeForAppWindow(aAppWindow, aBusyOk) { + // Sometimes we are given HTML windows, for which the logic below will + // bail. So we use a fast-path here that should work for HTML and should + // maybe also work with XUL. I'm not going to go into it... + if ( + aAppWindow.document && + aAppWindow.document.documentElement && + aAppWindow.document.documentElement.hasAttribute("windowtype") + ) { + return getWindowTypeOrId(aAppWindow.document.documentElement); + } + + let docshell = aAppWindow.docShell; + // we need the docshell to exist... + if (!docshell) { + return null; + } + + // we can't know if it's the right document until it's not busy + if (!aBusyOk && docshell.busyFlags) { + return null; + } + + // it also needs to have content loaded (it starts out not busy with no + // content viewer.) + if (docshell.contentViewer == null) { + return null; + } + + // now we're cooking! let's get the document... + let outerDoc = docshell.contentViewer.DOMDocument; + // and make sure it's not blank. that's also an intermediate state. + if (outerDoc.location.href == "about:blank") { + return null; + } + + // finally, we can now have a windowtype! + let windowType = getWindowTypeOrId(outerDoc.documentElement); + + if (windowType) { + return windowType; + } + + // As a last resort, use the name given to the DOM window. + let domWindow = aAppWindow.docShell.domWindow; + + return domWindow.name; +} + +var WindowWatcher = { + _inited: false, + _firstWindowOpened: false, + ensureInited() { + if (this._inited) { + return; + } + + // Add ourselves as an nsIWindowMediatorListener so we can here about when + // windows get registered with the window mediator. Because this + // generally happens + // Another possible means of getting this info would be to observe + // "xul-window-visible", but it provides no context and may still require + // polling anyways. + Services.wm.addListener(this); + + // Clean up any references to windows at the end of each test, and clean + // up the listeners/observers as the end of the session. + let observer = { + observe(subject, topic) { + WindowWatcher.monitoringList.length = 0; + WindowWatcher.waitingList.clear(); + if (topic == "quit-application-granted") { + Services.wm.removeListener(this); + Services.obs.removeObserver(this, "test-complete"); + Services.obs.removeObserver(this, "quit-application-granted"); + } + }, + }; + Services.obs.addObserver(observer, "test-complete"); + Services.obs.addObserver(observer, "quit-application-granted"); + + this._inited = true; + }, + + /** + * Track the windowtypes we are waiting on. Keys are windowtypes. When + * watching for new windows, values are initially null, and are set to an + * nsIAppWindow when we actually find the window. When watching for closing + * windows, values are nsIAppWindows. This symmetry lets us have windows + * that appear and dis-appear do so without dangerously confusing us (as + * long as another one comes along...) + */ + waitingList: new Map(), + /** + * Note that we will be looking for a window with the given window type + * (ex: "mailnews:search"). This allows us to be ready if an event shows + * up before waitForWindow is called. + */ + planForWindowOpen(aWindowType) { + this.waitingList.set(aWindowType, null); + }, + + /** + * Like planForWindowOpen but we check for already-existing windows. + */ + planForAlreadyOpenWindow(aWindowType) { + this.waitingList.set(aWindowType, null); + // We need to iterate over all the app windows and consider them all. + // We can't pass the window type because the window might not have a + // window type yet. + // because this iterates from old to new, this does the right thing in that + // side-effects of consider will pick the most recent window. + for (let appWindow of Services.wm.getAppWindowEnumerator(null)) { + if (!this.consider(appWindow)) { + this.monitoringList.push(appWindow); + } + } + }, + + /** + * The current windowType we are waiting to open. This is mainly a means of + * communicating the desired window type to monitorize without having to + * put the argument in the eval string. + */ + waitingForOpen: null, + /** + * Wait for the given windowType to open and finish loading. + * + * @returns The window wrapped in a MozMillController. + */ + waitForWindowOpen(aWindowType) { + this.waitingForOpen = aWindowType; + utils.waitFor( + () => this.monitorizeOpen(), + "Timed out waiting for window open!", + this._firstWindowOpened + ? WINDOW_OPEN_TIMEOUT_MS + : FIRST_WINDOW_EVER_TIMEOUT_MS, + this._firstWindowOpened + ? WINDOW_OPEN_CHECK_INTERVAL_MS + : FIRST_WINDOW_CHECK_INTERVAL_MS + ); + + this.waitingForOpen = null; + let appWindow = this.waitingList.get(aWindowType); + let domWindow = appWindow.docShell.domWindow; + this.waitingList.delete(aWindowType); + // spin the event loop to make sure any setTimeout 0 calls have gotten their + // time in the sun. + utils.sleep(0); + this._firstWindowOpened = true; + return new controller.MozMillController(domWindow); + }, + + /** + * Because the modal dialog spins its own event loop, the mozmill idiom of + * spinning your own event-loop as performed by waitFor is no good. We use + * this timer to generate our events so that we can have a waitFor + * equivalent. + * + * We only have one timer right now because modal dialogs that spawn modal + * dialogs are not tremendously likely. + */ + _timer: null, + _timerRuntimeSoFar: 0, + /** + * The test function to run when the modal dialog opens. + */ + subTestFunc: null, + planForModalDialog(aWindowType, aSubTestFunc) { + if (this._timer == null) { + this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + } + this.waitingForOpen = aWindowType; + this.subTestFunc = aSubTestFunc; + this.waitingList.set(aWindowType, null); + + this._timerRuntimeSoFar = 0; + this._timer.initWithCallback( + this, + WINDOW_OPEN_CHECK_INTERVAL_MS, + Ci.nsITimer.TYPE_REPEATING_SLACK + ); + }, + + /** + * This is the nsITimer notification we receive... + */ + notify() { + if (this.monitorizeOpen()) { + // okay, the window is opened, and we should be in its event loop now. + let appWindow = this.waitingList.get(this.waitingForOpen); + let domWindow = appWindow.docShell.domWindow; + let troller = new controller.MozMillController(domWindow); + + this._timer.cancel(); + + let self = this; + async function startTest() { + self.planForWindowClose(troller.window); + try { + await self.subTestFunc(troller); + } finally { + self.subTestFunc = null; + } + + // if the test failed, make sure we force the window closed... + // except I'm not sure how to easily figure that out... + // so just close it no matter what. + troller.window.close(); + self.waitForWindowClose(); + + self.waitingList.delete(self.waitingForOpen); + // now we are waiting for it to close... + self.waitingForClose = self.waitingForOpen; + self.waitingForOpen = null; + } + + let targetFocusedWindow = {}; + Services.focus.getFocusedElementForWindow( + domWindow, + true, + targetFocusedWindow + ); + targetFocusedWindow = targetFocusedWindow.value; + + let focusedWindow = {}; + if (Services.focus.activeWindow) { + Services.focus.getFocusedElementForWindow( + Services.focus.activeWindow, + true, + focusedWindow + ); + + focusedWindow = focusedWindow.value; + } + + if (focusedWindow == targetFocusedWindow) { + startTest(); + } else { + function onFocus(event) { + targetFocusedWindow.setTimeout(startTest, 0); + } + targetFocusedWindow.addEventListener("focus", onFocus, { + capture: true, + once: true, + }); + targetFocusedWindow.focus(); + } + } + // notify is only used for modal dialogs, which are never the first window, + // so we can always just use this set of timeouts/intervals. + this._timerRuntimeSoFar += WINDOW_OPEN_CHECK_INTERVAL_MS; + if (this._timerRuntimeSoFar >= WINDOW_OPEN_TIMEOUT_MS) { + this._timer.cancel(); + throw new Error("Timeout while waiting for modal dialog.\n"); + } + }, + + /** + * Symmetry for planForModalDialog; conceptually provides the waiting. In + * reality, all we do is potentially soak up the event loop a little to + */ + waitForModalDialog(aWindowType, aTimeout) { + // did the window already come and go? + if (this.subTestFunc == null) { + return; + } + // spin the event loop until we the window has come and gone. + utils.waitFor( + () => { + return this.waitingForOpen == null && this.monitorizeClose(); + }, + "Timeout waiting for modal dialog to open.", + aTimeout || WINDOW_OPEN_TIMEOUT_MS, + WINDOW_OPEN_CHECK_INTERVAL_MS + ); + this.waitingForClose = null; + }, + + planForWindowClose(aAppWindow) { + let windowType = getWindowTypeOrId(aAppWindow.document.documentElement); + this.waitingList.set(windowType, aAppWindow); + this.waitingForClose = windowType; + }, + + /** + * The current windowType we are waiting to close. Same deal as + * waitingForOpen, this makes the eval less crazy. + */ + waitingForClose: null, + waitForWindowClose() { + utils.waitFor( + () => this.monitorizeClose(), + "Timeout waiting for window to close!", + WINDOW_CLOSE_TIMEOUT_MS, + WINDOW_CLOSE_CHECK_INTERVAL_MS + ); + let didDisappear = this.waitingList.get(this.waitingForClose) == null; + let windowType = this.waitingForClose; + this.waitingList.delete(windowType); + this.waitingForClose = null; + if (!didDisappear) { + throw new Error(windowType + " window did not disappear!"); + } + }, + + /** + * Used by waitForWindowOpen to check all of the windows we are monitoring and + * then check if we have any results. + * + * @returns true if we found what we were |waitingForOpen|, false otherwise. + */ + monitorizeOpen() { + for (let iWin = this.monitoringList.length - 1; iWin >= 0; iWin--) { + let appWindow = this.monitoringList[iWin]; + if (this.consider(appWindow)) { + this.monitoringList.splice(iWin, 1); + } + } + + return ( + this.waitingList.has(this.waitingForOpen) && + this.waitingList.get(this.waitingForOpen) != null + ); + }, + + /** + * Used by waitForWindowClose to check if the window we are waiting to close + * actually closed yet. + * + * @returns true if it closed. + */ + monitorizeClose() { + return this.waitingList.get(this.waitingForClose) == null; + }, + + /** + * A list of app windows to monitor because they are loading and it's not yet + * possible to tell whether they are something we are looking for. + */ + monitoringList: [], + /** + * Monitor the given window's loading process until we can determine whether + * it is what we are looking for. + */ + monitorWindowLoad(aAppWindow) { + this.monitoringList.push(aAppWindow); + }, + + /** + * nsIWindowMediatorListener notification that a app window was opened. We + * check out the window, and if we were not able to fully consider it, we + * add it to our monitoring list. + */ + onOpenWindow(aAppWindow) { + // note: we would love to add our window activation/deactivation listeners + // and poke our unique id, but there is no contentViewer at this point + // and so there's no place to poke our unique id. (aAppWindow does not + // let us put expandos on; it's an XPCWrappedNative and explodes.) + // There may be nuances about outer window/inner window that make it + // feasible, but I have forgotten any such nuances I once knew. + if (!this.consider(aAppWindow)) { + this.monitorWindowLoad(aAppWindow); + } + }, + + /** + * Consider if the given window is something in our |waitingList|. + * + * @returns true if we were able to fully consider the object, false if we were + * not and need to be called again on the window later. This has no + * relation to whether the window was one in our waitingList or not. + * Check the waitingList structure for that. + */ + consider(aAppWindow) { + let windowType = getWindowTypeForAppWindow(aAppWindow); + if (windowType == null) { + return false; + } + + // stash the window if we were watching for it + if (this.waitingList.has(windowType)) { + this.waitingList.set(windowType, aAppWindow); + } + + return true; + }, + + /** + * Closing windows have the advantage of having to already have been loaded, + * so things like their windowtype are immediately available. + */ + onCloseWindow(aAppWindow) { + let domWindow = aAppWindow.docShell.domWindow; + let windowType = getWindowTypeOrId(domWindow.document.documentElement); + if (this.waitingList.has(windowType)) { + this.waitingList.set(windowType, null); + } + }, +}; + +/** + * Call this if the window you want to get may already be open. What we + * provide above just directly grabbing the window yourself is: + * - We wait for it to finish loading. + * + * @param aWindowType the window type that will be created. This is literally + * the value of the "windowtype" attribute on the window. The values tend + * to look like "app:windowname", for example "mailnews:search". + * + * @returns {MozmillController} + */ +function wait_for_existing_window(aWindowType) { + WindowWatcher.ensureInited(); + WindowWatcher.planForAlreadyOpenWindow(aWindowType); + return WindowWatcher.waitForWindowOpen(aWindowType); +} + +/** + * Call this just before you trigger the event that will cause a window to be + * displayed. + * In theory, we don't need this and could just do a sweep of existing windows + * when you call wait_for_new_window, or we could always just keep track of + * the most recently seen window of each type, but this is arguably more + * resilient in the face of multiple windows of the same type as long as you + * don't try and open them all at the same time. + * + * @param aWindowType the window type that will be created. This is literally + * the value of the "windowtype" attribute on the window. The values tend + * to look like "app:windowname", for example "mailnews:search". + */ +function plan_for_new_window(aWindowType) { + WindowWatcher.ensureInited(); + WindowWatcher.planForWindowOpen(aWindowType); +} + +/** + * Wait for the loading of the given window type to complete (that you + * previously told us about via |plan_for_new_window|), returning it wrapped + * in a MozmillController. + * + * @returns {MozmillController} + */ +function wait_for_new_window(aWindowType) { + let c = WindowWatcher.waitForWindowOpen(aWindowType); + // A nested event loop can get spun inside the Controller's constructor + // (which is arguably not a great idea), so it's important that we denote + // when we're actually leaving this function in case something crazy + // happens. + return c; +} + +async function async_plan_for_new_window(aWindowType) { + let domWindow = await BrowserTestUtils.domWindowOpened(null, async win => { + await BrowserTestUtils.waitForEvent(win, "load"); + return ( + win.document.documentElement.getAttribute("windowtype") == aWindowType + ); + }); + + await new Promise(r => domWindow.setTimeout(r)); + await new Promise(r => domWindow.setTimeout(r)); + + let domWindowController = new controller.MozMillController(domWindow); + return domWindowController; +} + +/** + * Plan for the imminent display of a modal dialog. Modal dialogs spin their + * own event loop which means that either that control flow will not return + * to the caller until the modal dialog finishes running. This means that + * you need to provide a sub-test function to be run inside the modal dialog + * (and it should not start with "test" or mozmill will also try and run it.) + * + * @param aWindowType The window type that you expect the modal dialog to have + * or the id of the window if there is no window type + * available. + * @param aSubTestFunction The sub-test function that will be run once the modal + * dialog appears and is loaded. This function should take one argument, + * a MozmillController against the modal dialog. + */ +function plan_for_modal_dialog(aWindowType, aSubTestFunction) { + WindowWatcher.ensureInited(); + WindowWatcher.planForModalDialog(aWindowType, aSubTestFunction); +} +/** + * In case the dialog might be stuck for a long time, you can pass an optional + * timeout. + * + * @param aTimeout Your custom timeout (default is WINDOW_OPEN_TIMEOUT_MS) + */ +function wait_for_modal_dialog(aWindowType, aTimeout) { + WindowWatcher.waitForModalDialog(aWindowType, aTimeout); +} + +/** + * Call this just before you trigger the event that will cause the provided + * controller's window to disappear. You then follow this with a call to + * |wait_for_window_close| when you want to block on verifying the close. + * + * @param aController The MozmillController, potentially returned from a call to + * wait_for_new_window, whose window should be disappearing. + */ +function plan_for_window_close(aController) { + WindowWatcher.ensureInited(); + WindowWatcher.planForWindowClose(aController.window); +} + +/** + * Wait for the closure of the window you noted you would listen for its close + * in plan_for_window_close. + */ +function wait_for_window_close() { + WindowWatcher.waitForWindowClose(); +} + +/** + * Close a window by calling window.close() on the controller. + * + * @param aController the controller whose window is to be closed. + */ +function close_window(aController) { + plan_for_window_close(aController); + aController.window.close(); + wait_for_window_close(); +} + +/** + * Wait for the window to be focused. + * + * @param aWindow the window to be focused. + */ +function wait_for_window_focused(aWindow) { + let targetWindow = {}; + + Services.focus.getFocusedElementForWindow(aWindow, true, targetWindow); + targetWindow = targetWindow.value; + + let focusedWindow = {}; + if (Services.focus.activeWindow) { + Services.focus.getFocusedElementForWindow( + Services.focus.activeWindow, + true, + focusedWindow + ); + focusedWindow = focusedWindow.value; + } + + let focused = false; + if (focusedWindow == targetWindow) { + focused = true; + } else { + targetWindow.addEventListener("focus", () => (focused = true), { + capture: true, + once: true, + }); + targetWindow.focus(); + } + + utils.waitFor( + () => focused, + "Timeout waiting for window to be focused.", + WINDOW_FOCUS_TIMEOUT_MS, + 100, + this + ); +} + +/** + * Given a <browser>, waits for it to completely load. + * + * @param aBrowser The <browser> element to wait for. + * @param aURLOrPredicate The URL that should be loaded (string) or a predicate + * for the URL (function). + * @returns The browser's content window wrapped in a MozMillController. + */ +function wait_for_browser_load(aBrowser, aURLOrPredicate) { + // aBrowser has all the fields we need already. + return _wait_for_generic_load(aBrowser, aURLOrPredicate); +} + +/** + * Given an HTML <frame> or <iframe>, waits for it to completely load. + * + * @param aFrame The element to wait for. + * @param aURLOrPredicate The URL that should be loaded (string) or a predicate + * for the URL (function). + * @returns The frame wrapped in a MozMillController. + */ +function wait_for_frame_load(aFrame, aURLOrPredicate) { + return _wait_for_generic_load(aFrame, aURLOrPredicate); +} + +/** + * Generic function to wait for some sort of document to load. We expect + * aDetails to have three fields: + * - webProgress: an nsIWebProgress associated with the contentWindow. + * - currentURI: the currently loaded page (nsIURI). + */ +function _wait_for_generic_load(aDetails, aURLOrPredicate) { + let predicate; + if (typeof aURLOrPredicate == "string") { + let expectedURL = NetUtil.newURI(aURLOrPredicate); + predicate = url => expectedURL.equals(url); + } else { + predicate = aURLOrPredicate; + } + + function isLoadedChecker() { + if (aDetails.webProgress?.isLoadingDocument) { + return false; + } + if ( + aDetails.contentDocument && + aDetails.contentDocument.readyState != "complete" + ) { + return false; + } + + return predicate( + aDetails.currentURI || + NetUtil.newURI(aDetails.contentWindow.location.href) + ); + } + + try { + utils.waitFor(isLoadedChecker); + } catch (e) { + if (e instanceof utils.TimeoutError) { + Assert.report( + true, + undefined, + undefined, + `Timeout waiting for content page to load. Current URL is: ${aDetails.currentURI.spec}` + ); + } else { + throw e; + } + } + + // Lie to mozmill to convince it to not explode because these frames never + // get a mozmillDocumentLoaded attribute (bug 666438). + let contentWindow = aDetails.contentWindow; + if (contentWindow) { + return new controller.MozMillController(contentWindow); + } + return null; +} + +/** + * Resize given window to new dimensions. + * + * @param aController window controller + * @param aWidth the requested window width + * @param aHeight the requested window height + */ +function resize_to(aController, aWidth, aHeight) { + aController.window.resizeTo(aWidth, aHeight); + // Give the event loop a spin in order to let the reality of an asynchronously + // interacting window manager have its impact. This still may not be + // sufficient. + utils.sleep(0); + utils.waitFor( + () => + aController.window.outerWidth == aWidth && + aController.window.outerHeight == aHeight, + "Timeout waiting for resize (current screen size: " + + aController.window.screen.availWidth + + "X" + + aController.window.screen.availHeight + + "), Requested width " + + aWidth + + " but got " + + aController.window.outerWidth + + ", Request height " + + aHeight + + " but got " + + aController.window.outerHeight, + 10000, + 50 + ); +} + +/** + * Dynamically-built/XBL-defined menus can be hard to work with, this makes it + * easier. + * + * @param aRootPopup The base popup. The caller is expected to activate it + * (by clicking/rightclicking the right widget). We will only wait for it + * to open if it is in the process. + * @param aActions An array of objects where each object has attributes + * with a value defined. We pick the menu item whose DOM node matches + * all the attributes with the specified names and value. We click whatever + * we find. We throw if the element being asked for is not found. + * @param aKeepOpen If set to true the popups are not closed after last click. + * + * @returns An array of popup elements that were left open. It will be + * an empty array if aKeepOpen was set to false. + */ +async function click_menus_in_sequence(aRootPopup, aActions, aKeepOpen) { + if (aRootPopup.state != "open") { + await BrowserTestUtils.waitForEvent(aRootPopup, "popupshown"); + } + + /** + * Check if a node's attributes match all those given in actionObj. + * Nodes that are obvious containers are skipped, and their children + * will be used to recursively find a match instead. + * + * @param {Element} node - The node to check. + * @param {object} actionObj - Contains attribute-value pairs to match. + * @returns {Element|null} The matched node or null if no match. + */ + let findMatch = function (node, actionObj) { + // Ignore some elements and just use their children instead. + if (node.localName == "hbox" || node.localName == "vbox") { + for (let i = 0; i < node.children.length; i++) { + let childMatch = findMatch(node.children[i]); + if (childMatch) { + return childMatch; + } + } + return null; + } + + let matchedAll = true; + for (let name in actionObj) { + let value = actionObj[name]; + if (!node.hasAttribute(name) || node.getAttribute(name) != value) { + matchedAll = false; + break; + } + } + return matchedAll ? node : null; + }; + + // These popups sadly do not close themselves, so we need to keep track + // of them so we can make sure they end up closed. + let closeStack = [aRootPopup]; + + let curPopup = aRootPopup; + for (let [iAction, actionObj] of aActions.entries()) { + let matchingNode = null; + let kids = curPopup.children; + for (let iKid = 0; iKid < kids.length; iKid++) { + let node = kids[iKid]; + matchingNode = findMatch(node, actionObj); + if (matchingNode) { + break; + } + } + + if (!matchingNode) { + throw new Error( + "Did not find matching menu item for action index " + + iAction + + ": " + + JSON.stringify(actionObj) + ); + } + + if (matchingNode.localName == "menu") { + matchingNode.openMenu(true); + } else { + curPopup.activateItem(matchingNode); + } + await new Promise(r => matchingNode.ownerGlobal.setTimeout(r, 500)); + + let newPopup = null; + if ("menupopup" in matchingNode) { + newPopup = matchingNode.menupopup; + } + if (newPopup) { + curPopup = newPopup; + closeStack.push(curPopup); + if (curPopup.state != "open") { + await BrowserTestUtils.waitForEvent(curPopup, "popupshown"); + } + } + } + + if (!aKeepOpen) { + close_popup_sequence(closeStack); + return []; + } + return closeStack; +} + +/** + * Close given menupopups. + * + * @param aCloseStack An array of menupopup elements that are to be closed. + * The elements are processed from the end of the array + * to the front (a stack). + */ +function close_popup_sequence(aCloseStack) { + while (aCloseStack.length) { + let curPopup = aCloseStack.pop(); + if (curPopup.state == "open") { + curPopup.focus(); + curPopup.hidePopup(); + } + } +} + +/** + * Click through the appmenu. Callers are expected to open the initial + * appmenu panelview (e.g. by clicking the appmenu button). We wait for it + * to open if it is not open yet. Then we use a recursive style approach + * with a sequence of event listeners handling "ViewShown" events. The + * `navTargets` parameter specifies items to click to navigate through the + * menu. The optional `nonNavTarget` parameter specifies a final item to + * click to perform a command after navigating through the menu. If this + * argument is omitted, callers can interact with the last view panel that + * is returned. Callers will then need to close the appmenu when they are + * done with it. + * + * @param {object[]} navTargets - Array of objects that contain + * attribute->value pairs. We pick the menu item whose DOM node matches + * all the attribute->value pairs. We click whatever we find. We throw + * if the element being asked for is not found. + * @param {object} [nonNavTarget] - Contains attribute->value pairs used + * to identify a final menu item to click. + * @param {Window} win - The window we're using. + * @returns {Element} The <vbox class="panel-subview-body"> element inside + * the last shown <panelview>. + */ +function _click_appmenu_in_sequence(navTargets, nonNavTarget, win) { + const rootPopup = win.document.getElementById("appMenu-popup"); + + function viewShownListener(navTargets, nonNavTarget, allDone, event) { + // Set up the next listener if there are more navigation targets. + if (navTargets.length > 0) { + rootPopup.addEventListener( + "ViewShown", + viewShownListener.bind( + null, + navTargets.slice(1), + nonNavTarget, + allDone + ), + { once: true } + ); + } + + const subview = event.target.querySelector(".panel-subview-body"); + + // Click a target if there is a target left to click. + const clickTarget = navTargets[0] || nonNavTarget; + + if (clickTarget) { + const kids = Array.from(subview.children); + const findFunction = node => { + let selectors = []; + for (let name in clickTarget) { + let value = clickTarget[name]; + selectors.push(`[${name}="${value}"]`); + } + let s = selectors.join(","); + return node.matches(s) || node.querySelector(s); + }; + + // Some views are dynamically populated after ViewShown, so we wait. + utils.waitFor( + () => kids.find(findFunction), + () => + "Waited but did not find matching menu item for target: " + + JSON.stringify(clickTarget) + ); + + const foundNode = kids.find(findFunction); + + EventUtils.synthesizeMouseAtCenter(foundNode, {}, foundNode.ownerGlobal); + } + + // We are all done when there are no more navigation targets. + if (navTargets.length == 0) { + allDone(subview); + } + } + + let done = false; + let subviewToReturn; + const allDone = subview => { + subviewToReturn = subview; + done = true; + }; + + utils.waitFor( + () => rootPopup.getAttribute("panelopen") == "true", + "Waited for the appmenu to open, but it never opened." + ); + + // Because the appmenu button has already been clicked in the calling + // code (to match click_menus_in_sequence), we have to call the first + // viewShownListener manually, using a fake event argument, to start the + // series of event listener calls. + const fakeEvent = { + target: win.document.getElementById("appMenu-mainView"), + }; + viewShownListener(navTargets, nonNavTarget, allDone, fakeEvent); + + utils.waitFor(() => done, "Timed out in _click_appmenu_in_sequence."); + return subviewToReturn; +} + +/** + * Utility wrapper function that clicks the main appmenu button to open the + * appmenu before calling `click_appmenu_in_sequence`. Makes things simple + * and concise for the most common case while still allowing for tests that + * open the appmenu via keyboard before calling `_click_appmenu_in_sequence`. + * + * @param {object[]} navTargets - Array of objects that contain + * attribute->value pairs to be used to identify menu items to click. + * @param {?object} nonNavTarget - Contains attribute->value pairs used + * to identify a final menu item to click. + * @param {Window} win - The window we're using. + * @returns {Element} The <vbox class="panel-subview-body"> element inside + * the last shown <panelview>. + */ +function click_through_appmenu(navTargets, nonNavTarget, win) { + let appmenu = win.document.getElementById("button-appmenu"); + EventUtils.synthesizeMouseAtCenter(appmenu, {}, appmenu.ownerGlobal); + return _click_appmenu_in_sequence(navTargets, nonNavTarget, win); +} diff --git a/comm/mail/test/browser/shared-modules/controller.jsm b/comm/mail/test/browser/shared-modules/controller.jsm new file mode 100644 index 0000000000..9c0bd084d9 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/controller.jsm @@ -0,0 +1,60 @@ +// ***** BEGIN LICENSE BLOCK ***** +// Version: MPL 1.1/GPL 2.0/LGPL 2.1 +// +// The contents of this file are subject to the Mozilla Public License Version +// 1.1 (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// http://www.mozilla.org/MPL/ +// +// Software distributed under the License is distributed on an "AS IS" basis, +// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +// for the specific language governing rights and limitations under the +// License. +// +// The Original Code is Mozilla Corporation Code. +// +// The Initial Developer of the Original Code is +// Adam Christian. +// Portions created by the Initial Developer are Copyright (C) 2008 +// the Initial Developer. All Rights Reserved. +// +// Contributor(s): +// Adam Christian <adam.christian@gmail.com> +// Mikeal Rogers <mikeal.rogers@gmail.com> +// Henrik Skupin <hskupin@mozilla.com> +// Aaron Train <atrain@mozilla.com> +// +// Alternatively, the contents of this file may be used under the terms of +// either the GNU General Public License Version 2 or later (the "GPL"), or +// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +// in which case the provisions of the GPL or the LGPL are applicable instead +// of those above. If you wish to allow use of your version of this file only +// under the terms of either the GPL or the LGPL, and not to allow others to +// use your version of this file under the terms of the MPL, indicate your +// decision by deleting the provisions above and replace them with the notice +// and other provisions required by the GPL or the LGPL. If you do not delete +// the provisions above, a recipient may use your version of this file under +// the terms of any one of the MPL, the GPL or the LGPL. +// +// ***** END LICENSE BLOCK ***** + +var EXPORTED_SYMBOLS = ["MozMillController"]; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); +var MozMillController = function (win) { + this.window = win; + + utils.waitFor( + function () { + return ( + win != null && + win.document.readyState == "complete" && + win.location.href != "about:blank" + ); + }, + "controller(): Window could not be initialized.", + undefined, + undefined, + this + ); +}; diff --git a/comm/mail/test/browser/shared-modules/moz.build b/comm/mail/test/browser/shared-modules/moz.build new file mode 100644 index 0000000000..d61395fac5 --- /dev/null +++ b/comm/mail/test/browser/shared-modules/moz.build @@ -0,0 +1,34 @@ +# vim: set filetype=python: +# 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/. + +TESTING_JS_MODULES.mozmill += [ + "AccountManagerHelpers.jsm", + "AddressBookHelpers.jsm", + "AttachmentHelpers.jsm", + "CloudfileHelpers.jsm", + "ComposeHelpers.jsm", + "ContentTabHelpers.jsm", + "controller.jsm", + "CustomizationHelpers.jsm", + "DOMHelpers.jsm", + "EventUtils.jsm", + "FolderDisplayHelpers.jsm", + "JunkHelpers.jsm", + "KeyboardHelpers.jsm", + "MockObjectHelpers.jsm", + "MouseEventHelpers.jsm", + "NewMailAccountHelpers.jsm", + "NNTPHelpers.jsm", + "NotificationBoxHelpers.jsm", + "OpenPGPTestUtils.jsm", + "PrefTabHelpers.jsm", + "PromptHelpers.jsm", + "QuickFilterBarHelpers.jsm", + "SearchWindowHelpers.jsm", + "SubscribeWindowHelpers.jsm", + "utils.jsm", + "ViewHelpers.jsm", + "WindowHelpers.jsm", +] diff --git a/comm/mail/test/browser/shared-modules/utils.jsm b/comm/mail/test/browser/shared-modules/utils.jsm new file mode 100644 index 0000000000..9605adfdca --- /dev/null +++ b/comm/mail/test/browser/shared-modules/utils.jsm @@ -0,0 +1,130 @@ +// ***** BEGIN LICENSE BLOCK ***** +// Version: MPL 1.1/GPL 2.0/LGPL 2.1 +// +// The contents of this file are subject to the Mozilla Public License Version +// 1.1 (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// http://www.mozilla.org/MPL/ +// +// Software distributed under the License is distributed on an "AS IS" basis, +// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +// for the specific language governing rights and limitations under the +// License. +// +// The Original Code is Mozilla Corporation Code. +// +// The Initial Developer of the Original Code is +// Adam Christian. +// Portions created by the Initial Developer are Copyright (C) 2008 +// the Initial Developer. All Rights Reserved. +// +// Contributor(s): +// Adam Christian <adam.christian@gmail.com> +// Mikeal Rogers <mikeal.rogers@gmail.com> +// Henrik Skupin <hskupin@mozilla.com> +// +// Alternatively, the contents of this file may be used under the terms of +// either the GNU General Public License Version 2 or later (the "GPL"), or +// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +// in which case the provisions of the GPL or the LGPL are applicable instead +// of those above. If you wish to allow use of your version of this file only +// under the terms of either the GPL or the LGPL, and not to allow others to +// use your version of this file under the terms of the MPL, indicate your +// decision by deleting the provisions above and replace them with the notice +// and other provisions required by the GPL or the LGPL. If you do not delete +// the provisions above, a recipient may use your version of this file under +// the terms of any one of the MPL, the GPL or the LGPL. +// +// ***** END LICENSE BLOCK ***** + +var EXPORTED_SYMBOLS = ["sleep", "TimeoutError", "waitFor"]; + +var hwindow = Services.appShell.hiddenDOMWindow; + +/** + * Sleep for the given amount of milliseconds + * + * @param {number} milliseconds + * Sleeps the given number of milliseconds + */ +function sleep(milliseconds) { + // We basically just call this once after the specified number of milliseconds + var timeup = false; + function wait() { + timeup = true; + } + hwindow.setTimeout(wait, milliseconds); + + var thread = Services.tm.currentThread; + while (!timeup) { + thread.processNextEvent(true); + } +} + +/** + * TimeoutError + * + * Error object used for timeouts + */ +function TimeoutError(message, fileName, lineNumber) { + var err = new Error(); + if (err.stack) { + this.stack = err.stack; + } + this.message = message === undefined ? err.message : message; + this.fileName = fileName === undefined ? err.fileName : fileName; + this.lineNumber = lineNumber === undefined ? err.lineNumber : lineNumber; +} +TimeoutError.prototype = new Error(); +TimeoutError.prototype.constructor = TimeoutError; +TimeoutError.prototype.name = "TimeoutError"; + +/** + * Waits for the callback evaluates to true + * + * @param callback Function that returns true when the waiting thould end. + * @param message {string or function} A message to throw if the callback didn't + * succeed until the timeout. Use a function + * if the message is to show some object state + * after the end of the wait (not before wait). + * @param timeout Milliseconds to wait until callback succeeds. + * @param interval Milliseconds to 'sleep' between checks of callback. + * @param thisObject (optional) 'this' to be passed into the callback. + */ +function waitFor(callback, message, timeout, interval, thisObject) { + timeout = timeout || 5000; + interval = interval || 100; + + var self = { counter: 0, result: callback.call(thisObject) }; + + function wait() { + self.counter += interval; + self.result = callback.call(thisObject); + } + + var timeoutInterval = hwindow.setInterval(wait, interval); + var thread = Services.tm.currentThread; + + while (!self.result && self.counter < timeout) { + thread.processNextEvent(true); + } + + hwindow.clearInterval(timeoutInterval); + + if (self.counter >= timeout) { + let messageText; + if (message) { + if (typeof message === "function") { + messageText = message(); + } else { + messageText = message; + } + } else { + messageText = "waitFor: Timeout exceeded for '" + callback + "'"; + } + + throw new TimeoutError(messageText); + } + + return true; +} |