From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- comm/mailnews/test/resources/.eslintrc.js | 5 + comm/mailnews/test/resources/IMAPpump.jsm | 143 ++ comm/mailnews/test/resources/LocalAccountUtils.jsm | 195 +++ comm/mailnews/test/resources/MailTestUtils.jsm | 611 ++++++++ comm/mailnews/test/resources/MessageGenerator.jsm | 1651 ++++++++++++++++++++ comm/mailnews/test/resources/MessageInjection.jsm | 987 ++++++++++++ comm/mailnews/test/resources/NetworkTestUtils.jsm | 294 ++++ comm/mailnews/test/resources/POP3pump.js | 269 ++++ comm/mailnews/test/resources/PromiseTestUtils.jsm | 316 ++++ comm/mailnews/test/resources/abSetup.js | 80 + comm/mailnews/test/resources/alertTestUtils.js | 487 ++++++ comm/mailnews/test/resources/filterTestUtils.js | 89 ++ .../test/resources/folderEventLogHelper.js | 0 comm/mailnews/test/resources/logHelper.js | 567 +++++++ comm/mailnews/test/resources/mailShutdown.js | 51 + .../test/resources/msgFolderListenerSetup.js | 429 +++++ comm/mailnews/test/resources/passwordStorage.js | 23 + comm/mailnews/test/resources/searchTestUtils.js | 134 ++ comm/mailnews/test/resources/smimeUtils.jsm | 71 + 19 files changed, 6402 insertions(+) create mode 100644 comm/mailnews/test/resources/.eslintrc.js create mode 100644 comm/mailnews/test/resources/IMAPpump.jsm create mode 100644 comm/mailnews/test/resources/LocalAccountUtils.jsm create mode 100644 comm/mailnews/test/resources/MailTestUtils.jsm create mode 100644 comm/mailnews/test/resources/MessageGenerator.jsm create mode 100644 comm/mailnews/test/resources/MessageInjection.jsm create mode 100644 comm/mailnews/test/resources/NetworkTestUtils.jsm create mode 100644 comm/mailnews/test/resources/POP3pump.js create mode 100644 comm/mailnews/test/resources/PromiseTestUtils.jsm create mode 100644 comm/mailnews/test/resources/abSetup.js create mode 100644 comm/mailnews/test/resources/alertTestUtils.js create mode 100644 comm/mailnews/test/resources/filterTestUtils.js create mode 100644 comm/mailnews/test/resources/folderEventLogHelper.js create mode 100644 comm/mailnews/test/resources/logHelper.js create mode 100644 comm/mailnews/test/resources/mailShutdown.js create mode 100644 comm/mailnews/test/resources/msgFolderListenerSetup.js create mode 100644 comm/mailnews/test/resources/passwordStorage.js create mode 100644 comm/mailnews/test/resources/searchTestUtils.js create mode 100644 comm/mailnews/test/resources/smimeUtils.jsm (limited to 'comm/mailnews/test/resources') diff --git a/comm/mailnews/test/resources/.eslintrc.js b/comm/mailnews/test/resources/.eslintrc.js new file mode 100644 index 0000000000..9fad83a7b1 --- /dev/null +++ b/comm/mailnews/test/resources/.eslintrc.js @@ -0,0 +1,5 @@ +"use strict"; + +module.exports = { + extends: ["plugin:mozilla/xpcshell-test", "plugin:mozilla/valid-jsdoc"], +}; diff --git a/comm/mailnews/test/resources/IMAPpump.jsm b/comm/mailnews/test/resources/IMAPpump.jsm new file mode 100644 index 0000000000..3f4b55266d --- /dev/null +++ b/comm/mailnews/test/resources/IMAPpump.jsm @@ -0,0 +1,143 @@ +/* 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/. */ + +/* + * This file provides a simple interface to the imap fake server. Demonstration + * of its use can be found in test_imapPump.js + * + * The code that forms the core of this file, in its original incarnation, + * was test_imapFolderCopy.js There have been several iterations since + * then. + */ + +var EXPORTED_SYMBOLS = ["IMAPPump", "setupIMAPPump", "teardownIMAPPump"]; + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); +var { localAccountUtils } = ChromeUtils.import( + "resource://testing-common/mailnews/LocalAccountUtils.jsm" +); +var { gThreadManager, nsMailServer } = ChromeUtils.import( + "resource://testing-common/mailnews/Maild.jsm" +); +var Imapd = ChromeUtils.import("resource://testing-common/mailnews/Imapd.jsm"); +var { updateAppInfo } = ChromeUtils.importESModule( + "resource://testing-common/AppInfo.sys.mjs" +); + +// define globals +var IMAPPump = { + daemon: null, // the imap fake server daemon + server: null, // the imap fake server + incomingServer: null, // nsIMsgIncomingServer for the imap server + inbox: null, // nsIMsgFolder/nsIMsgImapMailFolder for imap inbox + mailbox: null, // imap fake server mailbox +}; + +function setupIMAPPump(extensions) { + // Create Application info if we need it. + updateAppInfo(); + + // These are copied from imap's head_server.js to here so we can run + // this from any directory. + function makeServer(daemon, infoString) { + if (infoString in Imapd.configurations) { + return makeServer(daemon, Imapd.configurations[infoString].join(",")); + } + + function createHandler(d) { + var handler = new Imapd.IMAP_RFC3501_handler(d); + if (!infoString) { + infoString = "RFC2195"; + } + + var parts = infoString.split(/ *, */); + for (var part of parts) { + Imapd.mixinExtension(handler, Imapd["IMAP_" + part + "_extension"]); + } + return handler; + } + var server = new nsMailServer(createHandler, daemon); + server.start(); + return server; + } + + function createLocalIMAPServer() { + let server = localAccountUtils.create_incoming_server( + "imap", + IMAPPump.server.port, + "user", + "password" + ); + server.QueryInterface(Ci.nsIImapIncomingServer); + return server; + } + + // end copy from head_server.js + + IMAPPump.daemon = new Imapd.ImapDaemon(); + IMAPPump.server = makeServer(IMAPPump.daemon, extensions); + + IMAPPump.incomingServer = createLocalIMAPServer(); + + if (!localAccountUtils.inboxFolder) { + localAccountUtils.loadLocalMailAccount(); + } + + // We need an identity so that updateFolder doesn't fail + let localAccount = MailServices.accounts.createAccount(); + let identity = MailServices.accounts.createIdentity(); + localAccount.addIdentity(identity); + localAccount.defaultIdentity = identity; + localAccount.incomingServer = localAccountUtils.incomingServer; + + // Let's also have another account, using the same identity + let imapAccount = MailServices.accounts.createAccount(); + imapAccount.addIdentity(identity); + imapAccount.defaultIdentity = identity; + imapAccount.incomingServer = IMAPPump.incomingServer; + MailServices.accounts.defaultAccount = imapAccount; + + // The server doesn't support more than one connection + Services.prefs.setIntPref("mail.server.default.max_cached_connections", 1); + // We aren't interested in downloading messages automatically + Services.prefs.setBoolPref("mail.server.default.download_on_biff", false); + Services.prefs.setBoolPref("mail.biff.play_sound", false); + Services.prefs.setBoolPref("mail.biff.show_alert", false); + Services.prefs.setBoolPref("mail.biff.show_tray_icon", false); + Services.prefs.setBoolPref("mail.biff.animate_dock_icon", false); + Services.prefs.setBoolPref("mail.biff.alert.show_preview", false); + + IMAPPump.incomingServer.performExpand(null); + + IMAPPump.inbox = IMAPPump.incomingServer.rootFolder.getChildNamed("INBOX"); + IMAPPump.mailbox = IMAPPump.daemon.getMailbox("INBOX"); + IMAPPump.inbox instanceof Ci.nsIMsgImapMailFolder; +} + +// This will clear not only the imap accounts but also local accounts. +function teardownIMAPPump() { + // try to finish any pending operations + let thread = gThreadManager.currentThread; + while (thread.hasPendingEvents()) { + thread.processNextEvent(true); + } + + IMAPPump.inbox = null; + try { + let serverSink = IMAPPump.incomingServer.QueryInterface( + Ci.nsIImapServerSink + ); + serverSink.abortQueuedUrls(); + IMAPPump.incomingServer.closeCachedConnections(); + IMAPPump.server.resetTest(); + IMAPPump.server.stop(); + MailServices.accounts.removeIncomingServer(IMAPPump.incomingServer, false); + IMAPPump.incomingServer = null; + localAccountUtils.clearAll(); + } catch (ex) { + dump(ex); + } +} diff --git a/comm/mailnews/test/resources/LocalAccountUtils.jsm b/comm/mailnews/test/resources/LocalAccountUtils.jsm new file mode 100644 index 0000000000..11af0d1577 --- /dev/null +++ b/comm/mailnews/test/resources/LocalAccountUtils.jsm @@ -0,0 +1,195 @@ +/* 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/. */ + +const EXPORTED_SYMBOLS = ["localAccountUtils"]; + +// MailServices +const { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +// Local Mail Folders. Requires prior setup of profile directory + +var localAccountUtils = { + inboxFolder: undefined, + incomingServer: undefined, + rootFolder: undefined, + msgAccount: undefined, + + _localAccountInitialized: false, + _mailboxStoreContractID: undefined, + + pluggableStores: [ + "@mozilla.org/msgstore/berkeleystore;1", + "@mozilla.org/msgstore/maildirstore;1", + ], + + clearAll() { + this._localAccountInitialized = false; + if (this.msgAccount) { + MailServices.accounts.removeAccount(this.msgAccount); + } + this.incomingServer = undefined; + this.msgAccount = undefined; + this.inboxFolder = undefined; + this.rootFolder = undefined; + }, + + loadLocalMailAccount(storeID) { + if ( + (storeID && storeID == this._mailboxStoreContractID) || + (!storeID && this._localAccountInitialized) + ) { + return; + } + + this.clearAll(); + if (storeID) { + Services.prefs.setCharPref("mail.serverDefaultStoreContractID", storeID); + } + + this._mailboxStoreContractID = storeID; + MailServices.accounts.createLocalMailAccount(); + + this.incomingServer = MailServices.accounts.localFoldersServer; + this.msgAccount = MailServices.accounts.FindAccountForServer( + this.incomingServer + ); + + this.rootFolder = this.incomingServer.rootMsgFolder.QueryInterface( + Ci.nsIMsgLocalMailFolder + ); + + // Note: Inbox is not created automatically when there is no deferred server, + // so we need to create it. + this.inboxFolder = this.rootFolder + .createLocalSubfolder("Inbox") + .QueryInterface(Ci.nsIMsgLocalMailFolder); + // a local inbox should have a Mail flag! + this.inboxFolder.setFlag(Ci.nsMsgFolderFlags.Mail); + + // Force an initialization of the Inbox folder database. + this.inboxFolder.prettyName; + + this._localAccountInitialized = true; + }, + + /** + * Create an nsIMsgIncomingServer and an nsIMsgAccount to go with it. + * + * @param {string} aType - The type of the server (pop3, imap etc). + * @param {integer} aPort - The port the server is on. + * @param {string} aUsername - The username for the server. + * @param {string} aPassword - The password for the server. + * @param {string} aHostname - The hostname for the server (defaults to localhost). + * @returns {nsIMsgIncomingServer} The newly-created nsIMsgIncomingServer. + */ + create_incoming_server( + aType, + aPort, + aUsername, + aPassword, + aHostname = "localhost" + ) { + let serverAndAccount = localAccountUtils.create_incoming_server_and_account( + aType, + aPort, + aUsername, + aPassword, + aHostname + ); + return serverAndAccount.server; + }, + + /** + * Create an nsIMsgIncomingServer and an nsIMsgAccount to go with it. + * There are no identities created for the account. + * + * @param {string} aType - The type of the server (pop3, imap etc). + * @param {integer} aPort - The port the server is on. + * @param {string} aUsername - The username for the server. + * @param {string} aPassword - The password for the server. + * @param {string} aHostname - The hostname for the server (defaults to localhost). + * @returns {object} object + * @returns {nsIMsgIncomingServer} object.server Created server + * @returns {nsIMsgAccount} object.account Created account + */ + create_incoming_server_and_account( + aType, + aPort, + aUsername, + aPassword, + aHostname = "localhost" + ) { + let server = MailServices.accounts.createIncomingServer( + aUsername, + aHostname, + aType + ); + server.port = aPort; + if (aUsername != null) { + server.username = aUsername; + } + if (aPassword != null) { + server.password = aPassword; + } + + server.valid = false; + + let account = MailServices.accounts.createAccount(); + account.incomingServer = server; + if (aType == "pop3") { + // Several tests expect that mail is deferred to the local folders account, + // so do that. + this.loadLocalMailAccount(); + server.QueryInterface(Ci.nsIPop3IncomingServer); + server.deferredToAccount = this.msgAccount.key; + } + server.valid = true; + + return { server, account }; + }, + + /** + * Create an outgoing nsISmtpServer with the given parameters. + * + * @param {integer} aPort - The port the server is on. + * @param {string} aUsername - The username for the server + * @param {string} aPassword - The password for the server + * @param {string} [aHostname=localhost] - The hostname for the server. + * @returns {nsISmtpServer} The newly-created nsISmtpServer. + */ + create_outgoing_server(aPort, aUsername, aPassword, aHostname = "localhost") { + let server = MailServices.smtp.createServer(); + server.hostname = aHostname; + server.port = aPort; + server.authMethod = Ci.nsMsgAuthMethod.none; + return server; + }, + + /** + * Associate the given outgoing server with the given account. + * It does so by creating a new identity in the account using the given outgoing + * server. + * + * @param {nsIMsgAccount} aIncoming - The account to associate. + * @param {nsISmtpServer} aOutgoingServer - The outgoing server to associate. + * @param {bool} aSetAsDefault - Whether to set the outgoing server as the + * default for the account. + */ + associate_servers(aIncoming, aOutgoingServer, aSetAsDefault = false) { + if (!(aIncoming instanceof Ci.nsIMsgAccount)) { + throw new Error("aIncoming isn't an account"); + } + + let identity = MailServices.accounts.createIdentity(); + identity.smtpServerKey = aOutgoingServer.key; + + aIncoming.addIdentity(identity); + + if (aSetAsDefault) { + aIncoming.defaultIdentity = identity; + } + }, +}; diff --git a/comm/mailnews/test/resources/MailTestUtils.jsm b/comm/mailnews/test/resources/MailTestUtils.jsm new file mode 100644 index 0000000000..588e21521a --- /dev/null +++ b/comm/mailnews/test/resources/MailTestUtils.jsm @@ -0,0 +1,611 @@ +/* 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/. */ + +const EXPORTED_SYMBOLS = ["mailTestUtils"]; + +var { ctypes } = ChromeUtils.importESModule( + "resource://gre/modules/ctypes.sys.mjs" +); +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +// See Bug 903946 +function avoidUncaughtExceptionInExternalProtocolService() { + try { + Services.prefs.setCharPref( + "helpers.private_mime_types_file", + Services.prefs.getCharPref("helpers.global_mime_types_file") + ); + } catch (ex) {} + try { + Services.prefs.setCharPref( + "helpers.private_mailcap_file", + Services.prefs.getCharPref("helpers.global_mailcap_file") + ); + } catch (ex) {} +} +avoidUncaughtExceptionInExternalProtocolService(); + +var mailTestUtils = { + // Loads a file to a string + // If aCharset is specified, treats the file as being of that charset + loadFileToString(aFile, aCharset) { + var data = ""; + var fstream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance( + Ci.nsIFileInputStream + ); + fstream.init(aFile, -1, 0, 0); + + if (aCharset) { + var cstream = Cc[ + "@mozilla.org/intl/converter-input-stream;1" + ].createInstance(Ci.nsIConverterInputStream); + cstream.init(fstream, aCharset, 4096, 0x0000); + let str = {}; + while (cstream.readString(4096, str) != 0) { + data += str.value; + } + + cstream.close(); + } else { + var sstream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance( + Ci.nsIScriptableInputStream + ); + + sstream.init(fstream); + + let str = sstream.read(4096); + while (str.length > 0) { + data += str; + str = sstream.read(4096); + } + + sstream.close(); + } + + fstream.close(); + + return data; + }, + + // Loads a message to a string + // If aCharset is specified, treats the file as being of that charset + loadMessageToString(aFolder, aMsgHdr, aCharset) { + var data = ""; + let reusable = {}; + let bytesLeft = aMsgHdr.messageSize; + let stream = aFolder.getMsgInputStream(aMsgHdr, reusable); + if (aCharset) { + let cstream = Cc[ + "@mozilla.org/intl/converter-input-stream;1" + ].createInstance(Ci.nsIConverterInputStream); + cstream.init(stream, aCharset, 4096, 0x0000); + let str = {}; + let bytesToRead = Math.min(bytesLeft, 4096); + while (cstream.readString(bytesToRead, str) != 0) { + data += str.value; + bytesLeft -= bytesToRead; + if (bytesLeft <= 0) { + break; + } + bytesToRead = Math.min(bytesLeft, 4096); + } + cstream.close(); + } else { + var sstream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance( + Ci.nsIScriptableInputStream + ); + + sstream.init(stream); + + let bytesToRead = Math.min(bytesLeft, 4096); + var str = sstream.read(bytesToRead); + bytesLeft -= str.length; + while (str.length > 0) { + data += str; + if (bytesLeft <= 0) { + break; + } + bytesToRead = Math.min(bytesLeft, 4096); + str = sstream.read(bytesToRead); + bytesLeft -= str.length; + } + sstream.close(); + } + stream.close(); + + return data; + }, + + // Loads a message to a UTF-16 string. + loadMessageToUTF16String(folder, msgHdr, charset) { + let str = this.loadMessageToString(folder, msgHdr, charset); + let arr = new Uint8Array(Array.from(str, x => x.charCodeAt(0))); + return new TextDecoder().decode(arr); + }, + + // Gets the first message header in a folder. + firstMsgHdr(folder) { + let enumerator = folder.msgDatabase.enumerateMessages(); + let first = enumerator[Symbol.iterator]().next(); + return first.done ? null : first.value; + }, + + // Gets message header number N (0 based index) in a folder. + getMsgHdrN(folder, n) { + let i = 0; + for (let next of folder.msgDatabase.enumerateMessages()) { + if (i == n) { + return next; + } + i++; + } + return null; + }, + + /** + * Returns the file system a particular file is on. + * Currently supported on Windows only. + * + * @param {nsIFile} aFile - The file to get the file system for. + * @returns {string} The file system a particular file is on, or 'null' + * if not on Windows. + */ + get_file_system(aFile) { + if (!("@mozilla.org/windows-registry-key;1" in Cc)) { + dump("get_file_system() is supported on Windows only.\n"); + return null; + } + + // Win32 type and other constants. + const BOOL = ctypes.int32_t; + const MAX_PATH = 260; + + let kernel32 = ctypes.open("kernel32.dll"); + + try { + // Returns the path of the volume a file is on. + let GetVolumePathName = kernel32.declare( + "GetVolumePathNameW", + ctypes.winapi_abi, + BOOL, // return type: 1 indicates success, 0 failure + ctypes.char16_t.ptr, // in: lpszFileName + ctypes.char16_t.ptr, // out: lpszVolumePathName + ctypes.uint32_t // in: cchBufferLength + ); + + let filePath = aFile.path; + // The volume path should be at most 1 greater than than the length of the + // path -- add 1 for a trailing backslash if necessary, and 1 for the + // terminating null character. Note that the parentheses around the type are + // necessary for new to apply correctly. + let volumePath = new (ctypes.char16_t.array(filePath.length + 2))(); + + if (!GetVolumePathName(filePath, volumePath, volumePath.length)) { + throw new Error( + "Unable to get volume path for " + + filePath + + ", error " + + ctypes.winLastError + ); + } + + // Returns information about the file system for the given volume path. We just need + // the file system name. + let GetVolumeInformation = kernel32.declare( + "GetVolumeInformationW", + ctypes.winapi_abi, + BOOL, // return type: 1 indicates success, 0 failure + ctypes.char16_t.ptr, // in, optional: lpRootPathName + ctypes.char16_t.ptr, // out: lpVolumeNameBuffer + ctypes.uint32_t, // in: nVolumeNameSize + ctypes.uint32_t.ptr, // out, optional: lpVolumeSerialNumber + ctypes.uint32_t.ptr, // out, optional: lpMaximumComponentLength + ctypes.uint32_t.ptr, // out, optional: lpFileSystemFlags + ctypes.char16_t.ptr, // out: lpFileSystemNameBuffer + ctypes.uint32_t // in: nFileSystemNameSize + ); + + // We're only interested in the name of the file system. + let fsName = new (ctypes.char16_t.array(MAX_PATH + 1))(); + + if ( + !GetVolumeInformation( + volumePath, + null, + 0, + null, + null, + null, + fsName, + fsName.length + ) + ) { + throw new Error( + "Unable to get volume information for " + + volumePath.readString() + + ", error " + + ctypes.winLastError + ); + } + + return fsName.readString(); + } finally { + kernel32.close(); + } + }, + + /** + * Try marking a region of a file as sparse, so that zeros don't consume + * significant amounts of disk space. This is a platform-dependent routine and + * is not supported on all platforms. The current status of this function is: + * - Windows: Supported, but only on NTFS volumes. + * - Mac: Not supported. + * - Linux: As long as you seek to a position before writing, happens automatically + * on most file systems, so this function is a no-op. + * + * @param {nsIFile} aFile - The file to mark as sparse. + * @param {integer} aRegionStart - The start position of the sparse region, + * in bytes. + * @param {integer} aRegionBytes - The number of bytes to mark as sparse. + * @returns {boolean} Whether the OS and file system supports marking files as + * sparse. If this is true, then the file has been marked as sparse. + * If this isfalse, then the underlying system doesn't support marking files as + * sparse. If an exception is thrown, then the system does support marking + * files as sparse, but an error occurred while doing so. + * + */ + mark_file_region_sparse(aFile, aRegionStart, aRegionBytes) { + let fileSystem = this.get_file_system(aFile); + dump( + "[mark_file_region_sparse()] File system = " + + (fileSystem || "(unknown)") + + ", file region = at " + + this.toMiBString(aRegionStart) + + " for " + + this.toMiBString(aRegionBytes) + + "\n" + ); + + if ("@mozilla.org/windows-registry-key;1" in Cc) { + // On Windows, check whether the drive is NTFS. If it is, proceed. + // If it isn't, then bail out now, because in all probability it is + // FAT32, which doesn't support sparse files. + if (fileSystem != "NTFS") { + return false; + } + + // Win32 type and other constants. + const BOOL = ctypes.int32_t; + const HANDLE = ctypes.voidptr_t; + // A BOOLEAN (= BYTE = unsigned char) is distinct from a BOOL. + // http://blogs.msdn.com/b/oldnewthing/archive/2004/12/22/329884.aspx + const BOOLEAN = ctypes.unsigned_char; + const FILE_SET_SPARSE_BUFFER = new ctypes.StructType( + "FILE_SET_SPARSE_BUFFER", + [{ SetSparse: BOOLEAN }] + ); + // LARGE_INTEGER is actually a type union. We'll use the int64 representation + const LARGE_INTEGER = ctypes.int64_t; + const FILE_ZERO_DATA_INFORMATION = new ctypes.StructType( + "FILE_ZERO_DATA_INFORMATION", + [{ FileOffset: LARGE_INTEGER }, { BeyondFinalZero: LARGE_INTEGER }] + ); + + const GENERIC_WRITE = 0x40000000; + const OPEN_ALWAYS = 4; + const FILE_ATTRIBUTE_NORMAL = 0x80; + const INVALID_HANDLE_VALUE = new ctypes.Int64(-1); + const FSCTL_SET_SPARSE = 0x900c4; + const FSCTL_SET_ZERO_DATA = 0x980c8; + const FILE_BEGIN = 0; + + let kernel32 = ctypes.open("kernel32.dll"); + + try { + let CreateFile = kernel32.declare( + "CreateFileW", + ctypes.winapi_abi, + HANDLE, // return type: handle to the file + ctypes.char16_t.ptr, // in: lpFileName + ctypes.uint32_t, // in: dwDesiredAccess + ctypes.uint32_t, // in: dwShareMode + ctypes.voidptr_t, // in, optional: lpSecurityAttributes (note that + // we're cheating here by not declaring a + // SECURITY_ATTRIBUTES structure -- that's because + // we're going to pass in null anyway) + ctypes.uint32_t, // in: dwCreationDisposition + ctypes.uint32_t, // in: dwFlagsAndAttributes + HANDLE // in, optional: hTemplateFile + ); + + let filePath = aFile.path; + let hFile = CreateFile( + filePath, + GENERIC_WRITE, + 0, + null, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL, + null + ); + let hFileInt = ctypes.cast(hFile, ctypes.intptr_t); + if (ctypes.Int64.compare(hFileInt.value, INVALID_HANDLE_VALUE) == 0) { + throw new Error( + "CreateFile failed for " + + filePath + + ", error " + + ctypes.winLastError + ); + } + + try { + let DeviceIoControl = kernel32.declare( + "DeviceIoControl", + ctypes.winapi_abi, + BOOL, // return type: 1 indicates success, 0 failure + HANDLE, // in: hDevice + ctypes.uint32_t, // in: dwIoControlCode + ctypes.voidptr_t, // in, optional: lpInBuffer + ctypes.uint32_t, // in: nInBufferSize + ctypes.voidptr_t, // out, optional: lpOutBuffer + ctypes.uint32_t, // in: nOutBufferSize + ctypes.uint32_t.ptr, // out, optional: lpBytesReturned + ctypes.voidptr_t // inout, optional: lpOverlapped (again, we're + // cheating here by not having this as an + // OVERLAPPED structure + ); + // bytesReturned needs to be passed in, even though it's meaningless + let bytesReturned = new ctypes.uint32_t(); + let sparseBuffer = new FILE_SET_SPARSE_BUFFER(); + sparseBuffer.SetSparse = 1; + + // Mark the file as sparse + if ( + !DeviceIoControl( + hFile, + FSCTL_SET_SPARSE, + sparseBuffer.address(), + FILE_SET_SPARSE_BUFFER.size, + null, + 0, + bytesReturned.address(), + null + ) + ) { + throw new Error( + "Unable to mark file as sparse, error " + ctypes.winLastError + ); + } + + let zdInfo = new FILE_ZERO_DATA_INFORMATION(); + zdInfo.FileOffset = aRegionStart; + let regionEnd = aRegionStart + aRegionBytes; + zdInfo.BeyondFinalZero = regionEnd; + // Mark the region as a sparse region + if ( + !DeviceIoControl( + hFile, + FSCTL_SET_ZERO_DATA, + zdInfo.address(), + FILE_ZERO_DATA_INFORMATION.size, + null, + 0, + bytesReturned.address(), + null + ) + ) { + throw new Error( + "Unable to mark region as zero, error " + ctypes.winLastError + ); + } + + // Move to past the sparse region and mark it as the end of the file. The + // above DeviceIoControl call is useless unless followed by this. + let SetFilePointerEx = kernel32.declare( + "SetFilePointerEx", + ctypes.winapi_abi, + BOOL, // return type: 1 indicates success, 0 failure + HANDLE, // in: hFile + LARGE_INTEGER, // in: liDistanceToMove + LARGE_INTEGER.ptr, // out, optional: lpNewFilePointer + ctypes.uint32_t // in: dwMoveMethod + ); + if (!SetFilePointerEx(hFile, regionEnd, null, FILE_BEGIN)) { + throw new Error( + "Unable to set file pointer to end, error " + ctypes.winLastError + ); + } + + let SetEndOfFile = kernel32.declare( + "SetEndOfFile", + ctypes.winapi_abi, + BOOL, // return type: 1 indicates success, 0 failure + HANDLE // in: hFile + ); + if (!SetEndOfFile(hFile)) { + throw new Error( + "Unable to set end of file, error " + ctypes.winLastError + ); + } + + return true; + } finally { + let CloseHandle = kernel32.declare( + "CloseHandle", + ctypes.winapi_abi, + BOOL, // return type: 1 indicates success, 0 failure + HANDLE // in: hObject + ); + CloseHandle(hFile); + } + } finally { + kernel32.close(); + } + } else if ("nsILocalFileMac" in Ci) { + // Macs don't support marking files as sparse. + return false; + } else { + // Assuming Unix here. Unix file systems generally automatically sparsify + // files. + return true; + } + }, + + /** + * Converts a size in bytes into its mebibytes string representation. + * NB: 1 MiB = 1024 * 1024 = 1048576 B. + * + * @param {integer} aSize - The size in bytes. + * @returns {string} A string representing the size in mebibytes. + */ + toMiBString(aSize) { + return aSize / 1048576 + " MiB"; + }, + + /** + * A variant of do_timeout that accepts an actual function instead of + * requiring you to pass a string to evaluate. If the function throws an + * exception when invoked, we will use do_throw to ensure that the test fails. + * + * @param {integer} aDelayInMS - The number of milliseconds to wait before firing the timer. + * @param {Function} aFunc - The function to invoke when the timer fires. + * @param {object} [aFuncThis] - Optional 'this' pointer to use. + * @param {*[]} aFuncArgs - Optional list of arguments to pass to the function. + */ + _timer: null, + do_timeout_function(aDelayInMS, aFunc, aFuncThis, aFuncArgs) { + this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + let wrappedFunc = function () { + try { + aFunc.apply(aFuncThis, aFuncArgs); + } catch (ex) { + // we want to make sure that if the thing we call throws an exception, + // that this terminates the test. + do_throw(ex); + } + }; + this._timer.initWithCallback( + wrappedFunc, + aDelayInMS, + Ci.nsITimer.TYPE_ONE_SHOT + ); + }, + + /** + * Ensure the given nsIMsgFolder's database is up-to-date, calling the provided + * callback once the folder has been loaded. (This may be instantly or + * after a re-parse.) + * + * @param {nsIMsgFolder} aFolder - The nsIMsgFolder whose database you want + * to ensure is up-to-date. + * @param {Function} aCallback - The callback function to invoke once the + * folder has been loaded. + * @param {object} aCallbackThis - The 'this' to use when calling the callback. + * Pass null if your callback does not rely on 'this'. + * @param {*[]} aCallbackArgs - A list of arguments to pass to the callback + * via apply. If you provide [1,2,3], we will effectively call: + * aCallbackThis.aCallback(1,2,3); + * @param {boolean} [aSomeoneElseWillTriggerTheUpdate=false] If this is true, + * we do not trigger the updateFolder call and it is assumed someone else is + * taking care of that. + */ + updateFolderAndNotify( + aFolder, + aCallback, + aCallbackThis, + aCallbackArgs, + aSomeoneElseWillTriggerTheUpdate = false + ) { + // register for the folder loaded notification ahead of time... even though + // we may not need it... + let folderListener = { + onFolderEvent(aEventFolder, aEvent) { + if (aEvent == "FolderLoaded" && aFolder.URI == aEventFolder.URI) { + MailServices.mailSession.RemoveFolderListener(this); + aCallback.apply(aCallbackThis, aCallbackArgs); + } + }, + }; + + MailServices.mailSession.AddFolderListener( + folderListener, + Ci.nsIFolderListener.event + ); + + if (!aSomeoneElseWillTriggerTheUpdate) { + aFolder.updateFolder(null); + } + }, + + /** + * For when you want to compare elements non-strictly. + */ + non_strict_index_of(aArray, aElem) { + for (let [i, elem] of aArray.entries()) { + if (elem == aElem) { + return i; + } + } + return -1; + }, + + /** + * Click on a particular cell in a tree. `window` is not defined here in this + * file, so we can't provide it as a default argument. Similarly, we pass in + * `EventUtils` as an argument because importing it here does not work + * because `window` is not defined. + * + * @param {object} EventUtils - The EventUtils object. + * @param {Window} win - The window the tree is in. + * @param {Element} tree - The tree element. + * @param {number} row - The tree row to click on. + * @param {number} column - The tree column to click on. + * @param {object} event - The mouse event to synthesize, e.g. `{ clickCount: 2 }`. + */ + treeClick(EventUtils, win, tree, row, column, event) { + let coords = tree.getCoordsForCellItem(row, tree.columns[column], "cell"); + let treeChildren = tree.lastElementChild; + EventUtils.synthesizeMouse( + treeChildren, + coords.x + coords.width / 2, + coords.y + coords.height / 2, + event, + win + ); + }, + + /** + * For waiting until an element exists in a given document. Pass in the + * `MutationObserver` as an argument because importing it here does not work + * because `window` is not defined here. + * + * @param {object} MutationObserver - The MutationObserver object. + * @param {Document} doc - Document that contains the elements. + * @param {string} observedNodeId - Id of the element to observe. + * @param {string} awaitedNodeId - Id of the element that will soon exist. + * @returns {Promise.} - A promise fulfilled when the element exists. + */ + awaitElementExistence(MutationObserver, doc, observedNodeId, awaitedNodeId) { + return new Promise(resolve => { + let outerObserver = new MutationObserver((mutationsList, observer) => { + for (let mutation of mutationsList) { + if (mutation.type == "childList" && mutation.addedNodes.length) { + let element = doc.getElementById(awaitedNodeId); + + if (element) { + observer.disconnect(); + resolve(); + return; + } + } + } + }); + + let nodeToObserve = doc.getElementById(observedNodeId); + outerObserver.observe(nodeToObserve, { childList: true }); + }); + }, +}; diff --git a/comm/mailnews/test/resources/MessageGenerator.jsm b/comm/mailnews/test/resources/MessageGenerator.jsm new file mode 100644 index 0000000000..4e3f8b75f1 --- /dev/null +++ b/comm/mailnews/test/resources/MessageGenerator.jsm @@ -0,0 +1,1651 @@ +/* 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/. */ + +const EXPORTED_SYMBOLS = [ + "MessageGenerator", + "addMessagesToFolder", + "MessageScenarioFactory", + "SyntheticPartLeaf", + "SyntheticDegeneratePartEmpty", + "SyntheticPartMulti", + "SyntheticPartMultiMixed", + "SyntheticPartMultiParallel", + "SyntheticPartMultiDigest", + "SyntheticPartMultiAlternative", + "SyntheticPartMultiRelated", + "SyntheticPartMultiSignedSMIME", + "SyntheticPartMultiSignedPGP", + "SyntheticMessage", + "SyntheticMessageSet", +]; + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +/** + * A list of first names for use by MessageGenerator to create deterministic, + * reversible names. To keep things easily reversible, if you add names, make + * sure they have no spaces in them! + */ +var FIRST_NAMES = [ + "Andy", + "Bob", + "Chris", + "David", + "Emily", + "Felix", + "Gillian", + "Helen", + "Idina", + "Johnny", + "Kate", + "Lilia", + "Martin", + "Neil", + "Olof", + "Pete", + "Quinn", + "Rasmus", + "Sarah", + "Troels", + "Ulf", + "Vince", + "Will", + "Xavier", + "Yoko", + "Zig", +]; + +/** + * A list of last names for use by MessageGenerator to create deterministic, + * reversible names. To keep things easily reversible, if you add names, make + * sure they have no spaces in them! + */ +var LAST_NAMES = [ + "Anway", + "Bell", + "Clarke", + "Davol", + "Ekberg", + "Flowers", + "Gilbert", + "Hook", + "Ivarsson", + "Jones", + "Kurtz", + "Lowe", + "Morris", + "Nagel", + "Orzabal", + "Price", + "Quinn", + "Rolinski", + "Stanley", + "Tennant", + "Ulvaeus", + "Vannucci", + "Wiggs", + "Xavier", + "Young", + "Zig", +]; + +/** + * A list of adjectives used to construct a deterministic, reversible subject + * by MessageGenerator. To keep things easily reversible, if you add more, + * make sure they have no spaces in them! Also, make sure your additions + * don't break the secret Monty Python reference! + */ +var SUBJECT_ADJECTIVES = [ + "Big", + "Small", + "Huge", + "Tiny", + "Red", + "Green", + "Blue", + "My", + "Happy", + "Sad", + "Grumpy", + "Angry", + "Awesome", + "Fun", + "Lame", + "Funky", +]; + +/** + * A list of nouns used to construct a deterministic, reversible subject + * by MessageGenerator. To keep things easily reversible, if you add more, + * make sure they have no spaces in them! Also, make sure your additions + * don't break the secret Monty Python reference! + */ +var SUBJECT_NOUNS = [ + "Meeting", + "Party", + "Shindig", + "Wedding", + "Document", + "Report", + "Spreadsheet", + "Hovercraft", + "Aardvark", + "Giraffe", + "Llama", + "Velociraptor", + "Laser", + "Ray-Gun", + "Pen", + "Sword", +]; + +/** + * A list of suffixes used to construct a deterministic, reversible subject + * by MessageGenerator. These can (clearly) have spaces in them. Make sure + * your additions don't break the secret Monty Python reference! + */ +var SUBJECT_SUFFIXES = [ + "Today", + "Tomorrow", + "Yesterday", + "In a Fortnight", + "Needs Attention", + "Very Important", + "Highest Priority", + "Full Of Eels", + "In The Lobby", + "On Your Desk", + "In Your Car", + "Hiding Behind The Door", +]; + +/** + * Base class for MIME Part representation. + */ +function SyntheticPart(aProperties) { + if (aProperties) { + if ("contentType" in aProperties) { + this._contentType = aProperties.contentType; + } + if ("charset" in aProperties) { + this._charset = aProperties.charset; + } + if ("format" in aProperties) { + this._format = aProperties.format; + } + if ("filename" in aProperties) { + this._filename = aProperties.filename; + } + if ("boundary" in aProperties) { + this._boundary = aProperties.boundary; + } + if ("encoding" in aProperties) { + this._encoding = aProperties.encoding; + } + if ("contentId" in aProperties) { + this._contentId = aProperties.contentId; + } + if ("disposition" in aProperties) { + this._forceDisposition = aProperties.disposition; + } + if ("extraHeaders" in aProperties) { + this._extraHeaders = aProperties.extraHeaders; + } + } +} +SyntheticPart.prototype = { + _forceDisposition: null, + _encoding: null, + + get contentTypeHeaderValue() { + let s = this._contentType; + if (this._charset) { + s += "; charset=" + this._charset; + } + if (this._format) { + s += "; format=" + this._format; + } + if (this._filename) { + s += ';\r\n name="' + this._filename + '"'; + } + if (this._contentTypeExtra) { + for (let [key, value] of Object.entries(this._contentTypeExtra)) { + s += ";\r\n " + key + '="' + value + '"'; + } + } + if (this._boundary) { + s += ';\r\n boundary="' + this._boundary + '"'; + } + return s; + }, + get hasTransferEncoding() { + return this._encoding; + }, + get contentTransferEncodingHeaderValue() { + return this._encoding; + }, + get hasDisposition() { + return this._forceDisposition || this._filename || false; + }, + get contentDispositionHeaderValue() { + let s = ""; + if (this._forceDisposition) { + s += this._forceDisposition; + } else if (this._filename) { + s += 'attachment;\r\n filename="' + this._filename + '"'; + } + return s; + }, + get hasContentId() { + return this._contentId || false; + }, + get contentIdHeaderValue() { + return "<" + this._contentId + ">"; + }, + get hasExtraHeaders() { + return this._extraHeaders || false; + }, + get extraHeaders() { + return this._extraHeaders || false; + }, +}; + +/** + * Leaf MIME part, defaulting to text/plain. + */ +function SyntheticPartLeaf(aBody, aProperties) { + SyntheticPart.call(this, aProperties); + this.body = aBody; +} +SyntheticPartLeaf.prototype = { + __proto__: SyntheticPart.prototype, + _contentType: "text/plain", + _charset: "ISO-8859-1", + _format: "flowed", + _encoding: "7bit", + toMessageString() { + return this.body; + }, + prettyString(aIndent) { + return "Leaf: " + this._contentType; + }, +}; + +/** + * A part that tells us to produce NO output in a multipart section. So if our + * separator is "--BOB", we might produce "--BOB\n--BOB--\n" instead of having + * some headers and actual content in there. + * This is not a good idea and probably not legal either, but it happens and + * we need to test for it. + */ +function SyntheticDegeneratePartEmpty() {} +SyntheticDegeneratePartEmpty.prototype = { + prettyString(aIndent) { + return "Degenerate Empty Part"; + }, +}; + +/** + * Multipart (multipart/*) MIME part base class. + */ +function SyntheticPartMulti(aParts, aProperties) { + SyntheticPart.call(this, aProperties); + + this._boundary = "--------------CHOPCHOP" + this.BOUNDARY_COUNTER; + this.BOUNDARY_COUNTER_HOME.BOUNDARY_COUNTER += 1; + this.parts = aParts != null ? aParts : []; +} +SyntheticPartMulti.prototype = { + __proto__: SyntheticPart.prototype, + BOUNDARY_COUNTER: 0, + toMessageString() { + let s = "This is a multi-part message in MIME format.\r\n"; + for (let part of this.parts) { + s += "--" + this._boundary + "\r\n"; + if (part instanceof SyntheticDegeneratePartEmpty) { + continue; + } + s += "Content-Type: " + part.contentTypeHeaderValue + "\r\n"; + if (part.hasTransferEncoding) { + s += + "Content-Transfer-Encoding: " + + part.contentTransferEncodingHeaderValue + + "\r\n"; + } + if (part.hasDisposition) { + s += + "Content-Disposition: " + part.contentDispositionHeaderValue + "\r\n"; + } + if (part.hasContentId) { + s += "Content-ID: " + part.contentIdHeaderValue + "\r\n"; + } + if (part.hasExtraHeaders) { + for (let k in part.extraHeaders) { + let v = part.extraHeaders[k]; + s += k + ": " + v + "\r\n"; + } + } + s += "\r\n"; + s += part.toMessageString() + "\r\n"; + } + s += "--" + this._boundary + "--"; + return s; + }, + prettyString(aIndent) { + let nextIndent = aIndent != null ? aIndent + " " : ""; + + let s = "Container: " + this._contentType; + + for (let iPart = 0; iPart < this.parts.length; iPart++) { + let part = this.parts[iPart]; + s += + "\n" + nextIndent + (iPart + 1) + " " + part.prettyString(nextIndent); + } + + return s; + }, +}; +SyntheticPartMulti.prototype.BOUNDARY_COUNTER_HOME = + SyntheticPartMulti.prototype; + +/** + * Multipart mixed (multipart/mixed) MIME part. + */ +function SyntheticPartMultiMixed(...aArgs) { + SyntheticPartMulti.apply(this, aArgs); +} +SyntheticPartMultiMixed.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/mixed", +}; + +/** + * Multipart mixed (multipart/mixed) MIME part. + */ +function SyntheticPartMultiParallel(...aArgs) { + SyntheticPartMulti.apply(this, aArgs); +} +SyntheticPartMultiParallel.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/parallel", +}; + +/** + * Multipart digest (multipart/digest) MIME part. + */ +function SyntheticPartMultiDigest(...aArgs) { + SyntheticPartMulti.apply(this, aArgs); +} +SyntheticPartMultiDigest.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/digest", +}; + +/** + * Multipart alternative (multipart/alternative) MIME part. + */ +function SyntheticPartMultiAlternative(...aArgs) { + SyntheticPartMulti.apply(this, aArgs); +} +SyntheticPartMultiAlternative.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/alternative", +}; + +/** + * Multipart related (multipart/related) MIME part. + */ +function SyntheticPartMultiRelated(...aArgs) { + SyntheticPartMulti.apply(this, aArgs); +} +SyntheticPartMultiRelated.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/related", +}; + +var PKCS_SIGNATURE_MIME_TYPE = "application/x-pkcs7-signature"; +/** + * Multipart signed (multipart/signed) SMIME part. This is helperish and makes + * up a gibberish signature. We wrap the provided parts in the standard + * signature idiom + * + * @param {string} aPart - The content part to wrap. Only one part! + * Use a multipart if you need to cram extra stuff in there. + * @param {object} aProperties - Properties, propagated to SyntheticPart, see that. + */ +function SyntheticPartMultiSignedSMIME(aPart, aProperties) { + SyntheticPartMulti.call(this, [aPart], aProperties); + this.parts.push( + new SyntheticPartLeaf( + "I am not really a signature but let's hope no one figures it out.", + { + contentType: PKCS_SIGNATURE_MIME_TYPE, + name: "smime.p7s", + } + ) + ); +} +SyntheticPartMultiSignedSMIME.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/signed", + _contentTypeExtra: { + protocol: PKCS_SIGNATURE_MIME_TYPE, + micalg: "SHA1", + }, +}; + +var PGP_SIGNATURE_MIME_TYPE = "application/pgp-signature"; +/** + * Multipart signed (multipart/signed) PGP part. This is helperish and makes + * up a gibberish signature. We wrap the provided parts in the standard + * signature idiom + * + * @param {string} aPart - The content part to wrap. Only one part! + * Use a multipart if you need to cram extra stuff in there. + * @param {object} aProperties - Properties, propagated to SyntheticPart, see that. + */ +function SyntheticPartMultiSignedPGP(aPart, aProperties) { + SyntheticPartMulti.call(this, [aPart], aProperties); + this.parts.push( + new SyntheticPartLeaf( + "I am not really a signature but let's hope no one figures it out.", + { + contentType: PGP_SIGNATURE_MIME_TYPE, + } + ) + ); +} +SyntheticPartMultiSignedPGP.prototype = { + __proto__: SyntheticPartMulti.prototype, + _contentType: "multipart/signed", + _contentTypeExtra: { + protocol: PGP_SIGNATURE_MIME_TYPE, + micalg: "pgp-sha1", + }, +}; + +var _DEFAULT_META_STATES = { + junk: false, + read: false, +}; + +/** + * A synthetic message, created by the MessageGenerator. Captures both the + * ingredients that went into the synthetic message as well as the rfc822 form + * of the message. + * + * @param {object} [aHeaders] A dictionary of rfc822 header payloads. + * The key should be capitalized as you want it to appear in the output. + * This requires adherence to convention of this class. You are best to just + * use the helpers provided by this class. + * @param {object} [aBodyPart] - An instance of one of the many Synthetic part + * types available in this file. + * @param {object} [aMetaState] - A dictionary of meta-state about the message + * that is only relevant to the MessageInjection logic and perhaps some + * testing logic. + * @param {boolean} [aMetaState.junk=false] Is the method junk? + */ +function SyntheticMessage(aHeaders, aBodyPart, aMetaState) { + // we currently do not need to call SyntheticPart's constructor... + this.headers = aHeaders || {}; + this.bodyPart = aBodyPart || new SyntheticPartLeaf(""); + this.metaState = aMetaState || {}; + for (let key in _DEFAULT_META_STATES) { + let value = _DEFAULT_META_STATES[key]; + if (!(key in this.metaState)) { + this.metaState[key] = value; + } + } +} + +SyntheticMessage.prototype = { + __proto__: SyntheticPart.prototype, + _contentType: "message/rfc822", + _charset: null, + _format: null, + _encoding: null, + + /** @returns {string} The Message-Id header value. */ + get messageId() { + return this._messageId; + }, + /** + * Sets the Message-Id header value. + * + * @param {string} aMessageId - A unique string without the greater-than and + * less-than, we add those for you. + */ + set messageId(aMessageId) { + this._messageId = aMessageId; + this.headers["Message-Id"] = "<" + aMessageId + ">"; + }, + + /** @returns {Date} The message Date header value. */ + get date() { + return this._date; + }, + /** + * Sets the Date header to the given javascript Date object. + * + * @param {Date} aDate The date you want the message to claim to be from. + */ + set date(aDate) { + this._date = aDate; + let dateParts = aDate.toString().split(" "); + this.headers.Date = + dateParts[0] + + ", " + + dateParts[2] + + " " + + dateParts[1] + + " " + + dateParts[3] + + " " + + dateParts[4] + + " " + + dateParts[5].substring(3); + }, + + /** @returns {string} The message subject. */ + get subject() { + return this._subject; + }, + /** + * Sets the message subject. + * + * @param {string} aSubject - A string sans newlines or other illegal characters. + */ + set subject(aSubject) { + this._subject = aSubject; + this.headers.Subject = aSubject; + }, + + /** + * Given a tuple containing [a display name, an e-mail address], returns a + * string suitable for use in a to/from/cc header line. + * + * @param {string[]} aNameAndAddress - A list with two elements. The first + * should be the display name (sans wrapping quotes). The second element + * should be the e-mail address (sans wrapping greater-than/less-than). + */ + _formatMailFromNameAndAddress(aNameAndAddress) { + // if the name is encoded, do not put it in quotes! + if (aNameAndAddress[0].startsWith("=")) { + return aNameAndAddress[0] + " <" + aNameAndAddress[1] + ">"; + } + return '"' + aNameAndAddress[0] + '" <' + aNameAndAddress[1] + ">"; + }, + + /** + * Given a mailbox, parse out name and email. The mailbox + * can (per rfc 2822) be of two forms: + * 1) Name + * 2) me@example.org + * + * @returns {string[]} A tuple of name, email. + */ + _parseMailbox(mailbox) { + let matcher = mailbox.match(/(.*)<(.+@.+)>/); + if (!matcher) { + // no match -> second form + return ["", mailbox]; + } + + let name = matcher[1].trim(); + let email = matcher[2].trim(); + return [name, email]; + }, + + /** @returns {string[]} The name-and-address tuple used when setting the From header. */ + get from() { + return this._from; + }, + /** + * Sets the From header using the given tuple containing [a display name, + * an e-mail address]. + * + * @param {string[]} aNameAndAddress - A list with two elements. The first + * should be the display name (sans wrapping quotes). The second element + * should be the e-mail address (sans wrapping greater-than/less-than). + * Can also be a string, should then be a valid raw From: header value. + */ + set from(aNameAndAddress) { + if (typeof aNameAndAddress === "string") { + this._from = this._parseMailbox(aNameAndAddress); + this.headers.From = aNameAndAddress; + return; + } + this._from = aNameAndAddress; + this.headers.From = this._formatMailFromNameAndAddress(aNameAndAddress); + }, + + /** @returns {string} The display name part of the From header. */ + get fromName() { + return this._from[0]; + }, + /** @returns {string} The e-mail address part of the From header (no display name). */ + get fromAddress() { + return this._from[1]; + }, + + /** + * For our header storage, we may need to pre-add commas, this does it. + * + * @param {string[]} aList - A list of strings that is mutated so that every + * string in the list except the last one has a comma appended to it. + */ + _commaize(aList) { + for (let i = 0; i < aList.length - 1; i++) { + aList[i] = aList[i] + ","; + } + return aList; + }, + + /** + * @returns {string[][]} the comma-ized list of name-and-address tuples used + * to set the To header. + */ + get to() { + return this._to; + }, + /** + * Sets the To header using a list of tuples containing [a display name, + * an e-mail address]. + * + * @param {string[][]} aNameAndAddresses - A list of name-and-address tuples. + * Each tuple is alist with two elements. The first should be the + * display name (sans wrapping quotes). The second element should be the + * e-mail address (sans wrapping greater-than/less-than). + * Can also be a string, should then be a valid raw To: header value. + */ + set to(aNameAndAddresses) { + if (typeof aNameAndAddresses === "string") { + this._to = []; + let people = aNameAndAddresses.split(","); + for (let i = 0; i < people.length; i++) { + this._to.push(this._parseMailbox(people[i])); + } + + this.headers.To = aNameAndAddresses; + return; + } + this._to = aNameAndAddresses; + this.headers.To = this._commaize( + aNameAndAddresses.map(nameAndAddr => + this._formatMailFromNameAndAddress(nameAndAddr) + ) + ); + }, + /** @returns {string} The display name of the first intended recipient. */ + get toName() { + return this._to[0][0]; + }, + /** @returns {string} The email address (no display name) of the first recipient. */ + get toAddress() { + return this._to[0][1]; + }, + + /** + * @returns {string[][]} The comma-ized list of name-and-address tuples used + * to set the Cc header. + */ + get cc() { + return this._cc; + }, + /** + * Sets the Cc header using a list of tuples containing [a display name, + * an e-mail address]. + * + * @param {string[][]} aNameAndAddresses - A list of name-and-address tuples. + * Each tuple is a list with two elements. The first should be the + * display name (sans wrapping quotes). The second element should be the + * e-mail address (sans wrapping greater-than/less-than). + * Can also be a string, should then be a valid raw Cc: header value. + */ + set cc(aNameAndAddresses) { + if (typeof aNameAndAddresses === "string") { + this._cc = []; + let people = aNameAndAddresses.split(","); + for (let i = 0; i < people.length; i++) { + this._cc.push(this._parseMailbox(people[i])); + } + this.headers.Cc = aNameAndAddresses; + return; + } + this._cc = aNameAndAddresses; + this.headers.Cc = this._commaize( + aNameAndAddresses.map(nameAndAddr => + this._formatMailFromNameAndAddress(nameAndAddr) + ) + ); + }, + + get bodyPart() { + return this._bodyPart; + }, + set bodyPart(aBodyPart) { + this._bodyPart = aBodyPart; + this.headers["Content-Type"] = this._bodyPart.contentTypeHeaderValue; + }, + + /** + * Normalizes header values, which may be strings or arrays of strings, into + * a suitable string suitable for appending to the header name/key. + * + * @returns {string} A normalized string representation of the header + * value(s), which may include spanning multiple lines. + */ + _formatHeaderValues(aHeaderValues) { + // may not be an array + if (!(aHeaderValues instanceof Array)) { + return aHeaderValues; + } + // it's an array! + if (aHeaderValues.length == 1) { + return aHeaderValues[0]; + } + return aHeaderValues.join("\r\n\t"); + }, + + /** + * @returns {string} A string uniquely identifying this message, at least + * as long as the messageId is set and unique. + */ + toString() { + return "msg:" + this._messageId; + }, + + /** + * Convert the message and its hierarchy into a "pretty string". The message + * and each MIME part get their own line. The string never ends with a + * newline. For a non-multi-part message, only a single line will be + * returned. + * Messages have their subject displayed, everyone else just shows their + * content type. + */ + prettyString(aIndent) { + if (aIndent === undefined) { + aIndent = ""; + } + let nextIndent = aIndent + " "; + + let s = "Message: " + this.subject; + s += "\n" + nextIndent + "1 " + this.bodyPart.prettyString(nextIndent); + + return s; + }, + + /** + * @returns {string} This messages in rfc822 format, or something close enough. + */ + toMessageString() { + let lines = Object.keys(this.headers).map( + headerKey => + headerKey + ": " + this._formatHeaderValues(this.headers[headerKey]) + ); + + return lines.join("\r\n") + "\r\n\r\n" + this.bodyPart.toMessageString(); + }, + + toMboxString() { + return "From " + this._from[1] + "\r\n" + this.toMessageString() + "\r\n"; + }, + + /** + * @returns {nsIStringInputStream} This message in rfc822 format in a string stream. + */ + toStream() { + let stream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance( + Ci.nsIStringInputStream + ); + let str = this.toMessageString(); + stream.setData(str, str.length); + return stream; + }, + + /** + * Writes this message to an mbox stream. his means adding a "From " line + * and making sure we've got a trailing newline. + */ + writeToMboxStream(aStream) { + let str = this.toMboxString(); + aStream.write(str, str.length); + }, +}; + +/** + * Write a list of messages to a folder + * + * @param {SyntheticMessage[]} aMessages - The list of SyntheticMessages instances to write. + * @param {nsIMsgFolder} aFolder - The folder to write to. + */ +function addMessagesToFolder(aMessages, aFolder) { + let localFolder = aFolder.QueryInterface(Ci.nsIMsgLocalMailFolder); + for (let message of aMessages) { + localFolder.addMessage(message.toMboxString()); + } +} + +/** + * Represents a set of synthetic messages, also supporting insertion into and + * tracking of the message folders to which they belong. This then allows + * mutations of the messages (in their folders) for testing purposes. + * + * In general, you would create a synthetic message set by passing in only a + * list of synthetic messages, and then add then messages to nsIMsgFolders by + * using one of the addMessage* methods. This will populate the aMsgFolders + * and aFolderIndices values. (They are primarily intended for reasons of + * slicing, but people who know what they are doing can also use them.) + * + * @param {SyntheticMessage[]} aSynMessages The synthetic messages that should belong to this set. + * @param {nsIMsgFolder|nsIMsgFolder[]} [aMsgFolders] Optional nsIMsgFolder or list of folders. + * @param {number[]} [aFolderIndices] Optional list where each value is an index into the + * msgFolders attribute, specifying what folder the message can be found + * in. The value may also be null if the message has not yet been + * inserted into a folder. + */ +function SyntheticMessageSet(aSynMessages, aMsgFolders, aFolderIndices) { + this.synMessages = aSynMessages; + + if (Array.isArray(aMsgFolders)) { + this.msgFolders = aMsgFolders; + } else if (aMsgFolders) { + this.msgFolders = [aMsgFolders]; + } else { + this.msgFolders = []; + } + if (aFolderIndices == null) { + this.folderIndices = aSynMessages.map(_ => null); + } else { + this.folderIndices = aFolderIndices; + } +} +SyntheticMessageSet.prototype = { + /** + * Helper method for messageInjection to use to tell us it is injecting a + * message in a given folder. As a convenience, we also return the + * synthetic message. + * + * @protected + */ + _trackMessageAddition(aFolder, aMessageIndex) { + let aFolderIndex = this.msgFolders.indexOf(aFolder); + if (aFolderIndex == -1) { + aFolderIndex = this.msgFolders.push(aFolder) - 1; + } + this.folderIndices[aMessageIndex] = aFolderIndex; + return this.synMessages[aMessageIndex]; + }, + /** + * Helper method for use by |MessageInjection.async_move_messages| to tell us that it moved + * all the messages from aOldFolder to aNewFolder. + */ + _folderSwap(aOldFolder, aNewFolder) { + let folderIndex = this.msgFolders.indexOf(aOldFolder); + this.msgFolders[folderIndex] = aNewFolder; + }, + + /** + * Union this set with another set and return the (new) result. + * + * @param {SyntheticMessageSet} aOtherSet - The other synthetic message set. + * @returns {SyntheticMessageSet} A new SyntheticMessageSet containing the + * union of this set and the other set. + */ + union(aOtherSet) { + let messages = this.synMessages.concat(aOtherSet.synMessages); + let folders = this.msgFolders.concat(); + let indices = this.folderIndices.concat(); + + let folderUrisToIndices = {}; + for (let [iFolder, folder] of this.msgFolders.entries()) { + folderUrisToIndices[folder.URI] = iFolder; + } + + for (let iOther = 0; iOther < aOtherSet.synMessages.length; iOther++) { + let folderIndex = aOtherSet.folderIndices[iOther]; + if (folderIndex == null) { + indices.push(folderIndex); + } else { + let folder = aOtherSet.msgFolders[folderIndex]; + if (!(folder.URI in folderUrisToIndices)) { + folderUrisToIndices[folder.URI] = folders.length; + folders.push(folder); + } + indices.push(folderUrisToIndices[folder.URI]); + } + } + + return new SyntheticMessageSet(messages, folders, indices); + }, + + /** + * Get the single message header of the message at the given index; use + * |msgHdrs| if you want to get all the headers at once. + * + * @param {integer} aIndex + */ + getMsgHdr(aIndex) { + let folder = this.msgFolders[this.folderIndices[aIndex]]; + let synMsg = this.synMessages[aIndex]; + return folder.msgDatabase.getMsgHdrForMessageID(synMsg.messageId); + }, + + /** + * Get the URI for the message at the given index. + * + * @param {integer} aIndex + */ + getMsgURI(aIndex) { + let msgHdr = this.getMsgHdr(aIndex); + return msgHdr.folder.getUriForMsg(msgHdr); + }, + + /** + * @yields {nsIMsgDBHdr} A JS iterator of the message headers for all + * messages inserted into a folder. + */ + *msgHdrs() { + // get the databases + let msgDatabases = this.msgFolders.map(folder => folder.msgDatabase); + for (let [iMsg, synMsg] of this.synMessages.entries()) { + let folderIndex = this.folderIndices[iMsg]; + if (folderIndex != null) { + yield msgDatabases[folderIndex].getMsgHdrForMessageID(synMsg.messageId); + } + } + }, + /** + * @returns {nsIMsgDBHdr} A JS list of the message headers for all + * messages inserted into a folder. + */ + get msgHdrList() { + return Array.from(this.msgHdrs()); + }, + + /** + * @returns {object[]} - A list where each item is a list with two elements; + * the first is an nsIMsgFolder, and the second is a list of all of the nsIMsgDBHdrs + * for the synthetic messages in the set inserted into that folder. + */ + get foldersWithMsgHdrs() { + let results = this.msgFolders.map(folder => [folder, []]); + for (let [iMsg, synMsg] of this.synMessages.entries()) { + let folderIndex = this.folderIndices[iMsg]; + if (folderIndex != null) { + let [folder, msgHdrs] = results[folderIndex]; + msgHdrs.push( + folder.msgDatabase.getMsgHdrForMessageID(synMsg.messageId) + ); + } + } + return results; + }, + /** + * Sets the status of the messages to read/unread. + * + * @param {boolean} aRead - true/false to set messages as read/unread + * @param {nsIMsgDBHdr} aMsgHdr - A message header to work on. If not + * specified, mark all messages in the current set. + */ + setRead(aRead, aMsgHdr) { + let msgHdrs = aMsgHdr ? [aMsgHdr] : this.msgHdrList; + for (let msgHdr of msgHdrs) { + msgHdr.markRead(aRead); + } + }, + /** + * Sets the starred status of the messages. + * + * @param {boolean} aStarred - Starred status. + */ + setStarred(aStarred) { + for (let msgHdr of this.msgHdrs()) { + msgHdr.markFlagged(aStarred); + } + }, + /** + * Adds tag to the messages. + * + * @param {string} aTagName - Tag to add + */ + addTag(aTagName) { + for (let [folder, msgHdrs] of this.foldersWithMsgHdrs) { + folder.addKeywordsToMessages(msgHdrs, aTagName); + } + }, + /** + * Removes tag from the messages. + * + * @param {string} aTagName - Tag to remove + */ + removeTag(aTagName) { + for (let [folder, msgHdrs] of this.foldersWithMsgHdrs) { + folder.removeKeywordsFromMessages(msgHdrs, aTagName); + } + }, + /** + * Sets the junk score for the messages to junk/non-junk. It does not + * involve the bayesian classifier because we really don't want it + * affecting our unit tests! (Unless we were testing the bayesian + * classifier. Which I'm conveniently not. Feel free to add a + * "setJunkForRealsies" method if you are.) + * + * @param {boolean} aIsJunk - true/false to set messages to junk/non-junk + * @param {nsIMsgDBHdr} aMsgHdr - A message header to work on. If not + * specified, mark all messages in the current set. + * Generates a msgsJunkStatusChanged nsIMsgFolderListener notification. + */ + setJunk(aIsJunk, aMsgHdr) { + let junkscore = aIsJunk ? "100" : "0"; + let msgHdrs = aMsgHdr ? [aMsgHdr] : this.msgHdrList; + for (let msgHdr of msgHdrs) { + msgHdr.setStringProperty("junkscore", junkscore); + } + MailServices.mfn.notifyMsgsJunkStatusChanged(msgHdrs); + }, + + /** + * Slice the message set using the exact Array.prototype.slice semantics + * (because we call Array.prototype.slice). + */ + slice(...aArgs) { + let slicedMessages = this.synMessages.slice(...aArgs); + let slicedIndices = this.folderIndices.slice(...aArgs); + let sliced = new SyntheticMessageSet( + slicedMessages, + this.msgFolders, + slicedIndices + ); + if ("glodaMessages" in this && this.glodaMessages) { + sliced.glodaMessages = this.glodaMessages.slice(...aArgs); + } + return sliced; + }, +}; + +/** + * Provides mechanisms for creating vaguely interesting, but at least valid, + * SyntheticMessage instances. + */ +function MessageGenerator() { + this._clock = new Date(2000, 1, 1); + this._nextNameNumber = 0; + this._nextSubjectNumber = 0; + this._nextMessageIdNum = 0; +} + +MessageGenerator.prototype = { + /** + * The maximum number of unique names makeName can produce. + */ + MAX_VALID_NAMES: FIRST_NAMES.length * LAST_NAMES.length, + /** + * The maximum number of unique e-mail address makeMailAddress can produce. + */ + MAX_VALID_MAIL_ADDRESSES: FIRST_NAMES.length * LAST_NAMES.length, + /** + * The maximum number of unique subjects makeSubject can produce. + */ + MAX_VALID_SUBJECTS: + SUBJECT_ADJECTIVES.length * SUBJECT_NOUNS.length * SUBJECT_SUFFIXES, + + /** + * Generate a consistently determined (and reversible) name from a unique + * value. Currently up to 26*26 unique names can be generated, which + * should be sufficient for testing purposes, but if your code cares, check + * against MAX_VALID_NAMES. + * + * @param {integer} aNameNumber The 'number' of the name you want which must be less + * than MAX_VALID_NAMES. + * @returns {string} The unique name corresponding to the name number. + */ + makeName(aNameNumber) { + let iFirst = aNameNumber % FIRST_NAMES.length; + let iLast = + (iFirst + Math.floor(aNameNumber / FIRST_NAMES.length)) % + LAST_NAMES.length; + + return FIRST_NAMES[iFirst] + " " + LAST_NAMES[iLast]; + }, + + /** + * Generate a consistently determined (and reversible) e-mail address from + * a unique value; intended to work in parallel with makeName. Currently + * up to 26*26 unique addresses can be generated, but if your code cares, + * check against MAX_VALID_MAIL_ADDRESSES. + * + * @param {integer} aNameNumber - The 'number' of the mail address you want + * which must be ess than MAX_VALID_MAIL_ADDRESSES. + * @returns {string} The unique name corresponding to the name mail address. + */ + makeMailAddress(aNameNumber) { + let iFirst = aNameNumber % FIRST_NAMES.length; + let iLast = + (iFirst + Math.floor(aNameNumber / FIRST_NAMES.length)) % + LAST_NAMES.length; + + return ( + FIRST_NAMES[iFirst].toLowerCase() + + "@" + + LAST_NAMES[iLast].toLowerCase() + + ".invalid" + ); + }, + + /** + * Generate a pair of name and e-mail address. + * + * @param {integer} aNameNumber - The optional 'number' of the name and mail + * address you want. If you do not provide a value, we will increment an + * internal counter to ensure that a new name is allocated and that will not + * be re-used. If you use our automatic number once, you must use it + * always, unless you don't mind or can ensure no collisions occur between + * our number allocation and your uses. If provided, the number must be + * less than MAX_VALID_NAMES. + * @returns {string[]} A list containing two elements. + * The first is a name produced by a call to makeName, and the second an + * e-mail address produced by a call to makeMailAddress. + * This representation is used by the SyntheticMessage class when dealing + * with names and addresses. + */ + makeNameAndAddress(aNameNumber) { + if (aNameNumber === undefined) { + aNameNumber = this._nextNameNumber++; + } + return [this.makeName(aNameNumber), this.makeMailAddress(aNameNumber)]; + }, + + /** + * Generate and return multiple pairs of names and e-mail addresses. The + * names are allocated using the automatic mechanism as documented on + * makeNameAndAddress. You should accordingly not allocate / hard code name + * numbers on your own. + * + * @param {integer} aCount - The number of people you want name and address tuples for. + * @returns {string[][]} A list of aCount name-and-address tuples. + */ + makeNamesAndAddresses(aCount) { + let namesAndAddresses = []; + for (let i = 0; i < aCount; i++) { + namesAndAddresses.push(this.makeNameAndAddress()); + } + return namesAndAddresses; + }, + + /** + * Generate a consistently determined (and reversible) subject from a unique + * value. Up to MAX_VALID_SUBJECTS can be produced. + * + * @param {integer} aSubjectNumber - The subject number you want generated, + * must be less than MAX_VALID_SUBJECTS. + * @returns {string} The subject corresponding to the given subject number. + */ + makeSubject(aSubjectNumber) { + if (aSubjectNumber === undefined) { + aSubjectNumber = this._nextSubjectNumber++; + } + let iAdjective = aSubjectNumber % SUBJECT_ADJECTIVES.length; + let iNoun = + (iAdjective + Math.floor(aSubjectNumber / SUBJECT_ADJECTIVES.length)) % + SUBJECT_NOUNS.length; + let iSuffix = + (iNoun + + Math.floor( + aSubjectNumber / (SUBJECT_ADJECTIVES.length * SUBJECT_NOUNS.length) + )) % + SUBJECT_SUFFIXES.length; + return ( + SUBJECT_ADJECTIVES[iAdjective] + + " " + + SUBJECT_NOUNS[iNoun] + + " " + + SUBJECT_SUFFIXES[iSuffix] + ); + }, + + /** + * Fabricate a message-id suitable for the given synthetic message. Although + * we don't use the message yet, in theory it would let us tailor the + * message id to the server that theoretically might be sending it. Or some + * such. + * + * @param {SyntheticMessage} aSynthMessage - The synthetic message you would + * like us to make up a message-id for. We don't set the message-id on the + * message, that's up to you. + * @returns {string} A Message-Id suitable for the given message. + */ + makeMessageId(aSynthMessage) { + let msgId = this._nextMessageIdNum + "@made.up.invalid"; + this._nextMessageIdNum++; + return msgId; + }, + + /** + * Generates a valid date which is after all previously issued dates by this + * method, ensuring an apparent ordering of time consistent with the order + * in which code is executed / messages are generated. + * If you need a precise time ordering or precise times, make them up + * yourself. + * + * @returns {Date} - A made-up time in JavaScript Date object form. + */ + makeDate() { + let date = this._clock; + // advance time by an hour + this._clock = new Date(date.valueOf() + 60 * 60 * 1000); + return date; + }, + + /** + * Description for makeMessage options parameter. + * + * @typedef MakeMessageOptions + * @property {number} [age] A dictionary with potential attributes 'minutes', + * 'hours', 'days', 'weeks' to specify the message be created that far in + * the past. + * @property {object} [attachments] A list of dictionaries suitable for passing to + * syntheticPartLeaf, plus a 'body' attribute that has already been + * encoded. Line chopping is on you FOR NOW. + * @property {SyntheticPartLeaf} [body] A dictionary suitable for passing to SyntheticPart plus + * a 'body' attribute that has already been encoded (if encoding is + * required). Line chopping is on you FOR NOW. Alternately, use + * bodyPart. + * @property {SyntheticPartLeaf} [bodyPart] A SyntheticPart to uses as the body. If you + * provide an attachments value, this part will be wrapped in a + * multipart/mixed to also hold your attachments. (You can put + * attachments in the bodyPart directly if you want and not use + * attachments.) + * @property {string} [callerData] A value to propagate to the callerData attribute + * on the resulting message. + * @property {string[][]} [cc] A list of cc recipients (name and address pairs). If + * omitted, no cc is generated. + * @property {string[][]} [from] The name and value pair this message should be from. + * Defaults to the first recipient if this is a reply, otherwise a new + * person is synthesized via |makeNameAndAddress|. + * @property {string} [inReplyTo] the SyntheticMessage this message should be in + * reply-to. If that message was in reply to another message, we will + * appropriately compensate for that. If a SyntheticMessageSet is + * provided we will use the first message in the set. + * @property {boolean} [replyAll] a boolean indicating whether this should be a + * reply-to-all or just to the author of the message. (er, to-only, not + * cc.) + * @property {string} [subject] subject to use; you are responsible for doing any + * encoding before passing it in. + * @property {string[][]} [to] The list of recipients for this message, defaults to a + * set of toCount newly created persons. + * @property {number} [toCount=1] the number of people who the message should be to. + * @property {object} [clobberHeaders] An object whose contents will overwrite the + * contents of the headers object. This should only be used to construct + * illegal header values; general usage should use another explicit + * mechanism. + * @property {boolean} [junk] Should this message be flagged as junk for the benefit + * of the MessageInjection helper so that it can know to flag the message + * as junk? We have no concept of marking a message as definitely not + * junk at this point. + * @property {boolean} [read] Should this message be marked as already read? + */ + /** + * Create a SyntheticMessage. All arguments are optional, but allow + * additional control. With no arguments specified, a new name/address will + * be generated that has not been used before, and sent to a new name/address + * that has not been used before. + * + * @param {MakeMessageOptions} aArgs + * @returns {SyntheticMessage} a SyntheticMessage fashioned just to your liking. + */ + makeMessage(aArgs) { + aArgs = aArgs || {}; + let msg = new SyntheticMessage(); + + if (aArgs.inReplyTo) { + // If inReplyTo is a SyntheticMessageSet, just use the first message in + // the set because the caller may be using them. + let srcMsg = aArgs.inReplyTo.synMessages + ? aArgs.inReplyTo.synMessages[0] + : aArgs.inReplyTo; + + msg.parent = srcMsg; + msg.parent.children.push(msg); + + msg.subject = srcMsg.subject.startsWith("Re: ") + ? srcMsg.subject + : "Re: " + srcMsg.subject; + if (aArgs.replyAll) { + msg.to = [srcMsg.from].concat(srcMsg.to.slice(1)); + } else { + msg.to = [srcMsg.from]; + } + msg.from = srcMsg.to[0]; + + // we want the <>'s. + msg.headers["In-Reply-To"] = srcMsg.headers["Message-Id"]; + msg.headers.References = (srcMsg.headers.References || []).concat([ + srcMsg.headers["Message-Id"], + ]); + } else { + msg.parent = null; + + msg.subject = aArgs.subject || this.makeSubject(); + msg.from = aArgs.from || this.makeNameAndAddress(); + msg.to = aArgs.to || this.makeNamesAndAddresses(aArgs.toCount || 1); + if (aArgs.cc) { + msg.cc = aArgs.cc; + } + } + + msg.children = []; + msg.messageId = this.makeMessageId(msg); + if (aArgs.age) { + let age = aArgs.age; + // start from 'now' + let ts = new Date().valueOf(); + if (age.minutes) { + ts -= age.minutes * 60 * 1000; + } + if (age.hours) { + ts -= age.hours * 60 * 60 * 1000; + } + if (age.days) { + ts -= age.days * 24 * 60 * 60 * 1000; + } + if (age.weeks) { + ts -= age.weeks * 7 * 24 * 60 * 60 * 1000; + } + msg.date = new Date(ts); + } else { + msg.date = this.makeDate(); + } + + if ("clobberHeaders" in aArgs) { + for (let key in aArgs.clobberHeaders) { + let value = aArgs.clobberHeaders[key]; + if (value === null) { + delete msg.headers[key]; + } else { + msg.headers[key] = value; + } + // clobber helper... + if (key == "From") { + msg._from = ["", ""]; + } + if (key == "To") { + msg._to = [["", ""]]; + } + if (key == "Cc") { + msg._cc = [["", ""]]; + } + } + } + + if ("junk" in aArgs && aArgs.junk) { + msg.metaState.junk = true; + } + if ("read" in aArgs && aArgs.read) { + msg.metaState.read = true; + } + + let bodyPart; + if (aArgs.bodyPart) { + bodyPart = aArgs.bodyPart; + } else if (aArgs.body) { + bodyPart = new SyntheticPartLeaf(aArgs.body.body, aArgs.body); + } else { + // Different messages should have a chance at different bodies. + bodyPart = new SyntheticPartLeaf("Hello " + msg.toName + "!"); + } + + // if it has any attachments, create a multipart/mixed to be the body and + // have it be the parent of the existing body and all the attachments + if (aArgs.attachments) { + let parts = [bodyPart]; + for (let attachDesc of aArgs.attachments) { + parts.push(new SyntheticPartLeaf(attachDesc.body, attachDesc)); + } + bodyPart = new SyntheticPartMultiMixed(parts); + } + + msg.bodyPart = bodyPart; + + msg.callerData = aArgs.callerData; + + return msg; + }, + + /** + * Create an encrypted SMime message. It's just a wrapper around makeMessage, + * that sets the right content-type. Use like makeMessage. + * + * @param {MakeMessageOptions} aOptions + * @returns {SyntheticMessage} + */ + makeEncryptedSMimeMessage(aOptions) { + if (!aOptions) { + aOptions = {}; + } + aOptions.clobberHeaders = { + "Content-Transfer-Encoding": "base64", + "Content-Disposition": 'attachment; filename="smime.p7m"', + }; + if (!aOptions.body) { + aOptions.body = {}; + } + aOptions.body.contentType = 'application/pkcs7-mime; name="smime.p7m"'; + let msg = this.makeMessage(aOptions); + return msg; + }, + + /** + * Create an encrypted OpenPGP message. It's just a wrapper around makeMessage, + * that sets the right content-type. Use like makeMessage. + * + * @param {MakeMessageOptions} aOptions + * @returns {SyntheticMessage} + */ + makeEncryptedOpenPGPMessage(aOptions) { + if (!aOptions) { + aOptions = {}; + } + aOptions.clobberHeaders = { + "Content-Transfer-Encoding": "base64", + }; + if (!aOptions.body) { + aOptions.body = {}; + } + aOptions.body.contentType = + 'multipart/encrypted; protocol="application/pgp-encrypted"'; + let msg = this.makeMessage(aOptions); + return msg; + }, + + MAKE_MESSAGES_DEFAULTS: { + count: 10, + }, + MAKE_MESSAGES_PROPAGATE: [ + "attachments", + "body", + "cc", + "from", + "inReplyTo", + "subject", + "to", + "clobberHeaders", + "junk", + "read", + ], + /** + * Given a set definition, produce a list of synthetic messages. + * + * The set definition supports the following attributes: + * count: The number of messages to create. + * age: As used by makeMessage. + * age_incr: Similar to age, but used to increment the values in the age + * dictionary (assuming a value of zero if omitted). + * + * @param {object} aSetDef - Message properties, see MAKE_MESSAGES_PROPAGATE. + * @param {integer} [aSetDef.msgsPerThread=1] The number of messages per thread. + * If you want to create direct-reply threads, you can pass a value for this + * and have it not be one. If you need fancier reply situations, + * directly use a scenario or hook us up to support that. + * + * Also supported are the following attributes as defined by makeMessage: + * attachments, body, from, inReplyTo, subject, to, clobberHeaders, junk + * + * If omitted, the following defaults are used, but don't depend on this as we + * can change these at any time: + * - count: 10 + */ + makeMessages(aSetDef) { + let messages = []; + + let args = {}; + // zero out all the age_incr fields in age (if present) + if (aSetDef.age_incr) { + args.age = {}; + for (let unit of Object.keys(aSetDef.age_incr)) { + args.age[unit] = 0; + } + } + // copy over the initial values from age (if present) + if (aSetDef.age) { + args.age = args.age || {}; + for (let [unit, value] of Object.entries(aSetDef.age)) { + args.age[unit] = value; + } + } + // just copy over any attributes found from MAKE_MESSAGES_PROPAGATE + for (let propAttrName of this.MAKE_MESSAGES_PROPAGATE) { + if (aSetDef[propAttrName]) { + args[propAttrName] = aSetDef[propAttrName]; + } + } + + let count = aSetDef.count || this.MAKE_MESSAGES_DEFAULTS.count; + let messagsPerThread = aSetDef.msgsPerThread || 1; + let lastMessage = null; + for (let iMsg = 0; iMsg < count; iMsg++) { + // primitive threading support... + if (lastMessage && iMsg % messagsPerThread != 0) { + args.inReplyTo = lastMessage; + } else if (!("inReplyTo" in aSetDef)) { + args.inReplyTo = null; + } + lastMessage = this.makeMessage(args); + messages.push(lastMessage); + + if (aSetDef.age_incr) { + for (let [unit, delta] of Object.entries(aSetDef.age_incr)) { + args.age[unit] += delta; + } + } + } + + return messages; + }, +}; + +/** + * Repository of generative message scenarios. Uses the magic bindMethods + * function below to allow you to reference methods/attributes without worrying + * about how those methods will get the right 'this' pointer if passed as + * simply a function argument to someone. So if you do: + * foo = messageScenarioFactory.method, followed by foo(...), it will be + * equivalent to having simply called messageScenarioFactory.method(...). + * (Normally this would not be the case when using JavaScript.) + * + * @param {MessageGenerator} [aMessageGenerator] The optional message generator we should use. + * If you don't pass one, we create our own. You would want to pass one so + * that if you also create synthetic messages directly via the message + * generator then the two sources can avoid duplicate use of the same + * names/addresses/subjects/message-ids. + */ +function MessageScenarioFactory(aMessageGenerator) { + if (!aMessageGenerator) { + aMessageGenerator = new MessageGenerator(); + } + this._msgGen = aMessageGenerator; +} + +MessageScenarioFactory.prototype = { + /** Create a chain of direct-reply messages of the given length. */ + directReply(aNumMessages) { + aNumMessages = aNumMessages || 2; + let messages = [this._msgGen.makeMessage()]; + for (let i = 1; i < aNumMessages; i++) { + messages.push(this._msgGen.makeMessage({ inReplyTo: messages[i - 1] })); + } + return messages; + }, + + /** Two siblings (present), one parent (missing). */ + siblingsMissingParent() { + let missingParent = this._msgGen.makeMessage(); + let msg1 = this._msgGen.makeMessage({ inReplyTo: missingParent }); + let msg2 = this._msgGen.makeMessage({ inReplyTo: missingParent }); + return [msg1, msg2]; + }, + + /** Present parent, missing child, present grand-child. */ + missingIntermediary() { + let msg1 = this._msgGen.makeMessage(); + let msg2 = this._msgGen.makeMessage({ inReplyTo: msg1 }); + let msg3 = this._msgGen.makeMessage({ inReplyTo: msg2 }); + return [msg1, msg3]; + }, + + /** + * The root message and all non-leaf nodes have aChildrenPerParent children, + * for a total of aHeight layers. (If aHeight is 1, we have just the root; + * if aHeight is 2, the root and his aChildrePerParent children.) + */ + fullPyramid(aChildrenPerParent, aHeight) { + let msgGen = this._msgGen; + let root = msgGen.makeMessage(); + let messages = [root]; + function helper(aParent, aRemDepth) { + for (let iChild = 0; iChild < aChildrenPerParent; iChild++) { + let child = msgGen.makeMessage({ inReplyTo: aParent }); + messages.push(child); + if (aRemDepth) { + helper(child, aRemDepth - 1); + } + } + } + if (aHeight > 1) { + helper(root, aHeight - 2); + } + return messages; + }, +}; + +/** + * Decorate the given object's methods will python-style method binding. We + * create a getter that returns a method that wraps the call, providing the + * actual method with the 'this' of the object that was 'this' when the getter + * was called. + * Note that we don't follow the prototype chain; we only process the object you + * immediately pass to us. This does not pose a problem for the 'this' magic + * because we are using a getter and 'this' in js always refers to the object + * in question (never any part of its prototype chain). As such, you probably + * want to invoke us on your prototype object(s). + * + * @param {object} aObj - The object on whom we want to perform magic binding. + * This should probably be your prototype object. + */ +function bindMethods(aObj) { + for (let [name, ubfunc] of Object.entries(aObj)) { + // the variable binding needs to get captured... + let realFunc = ubfunc; + delete aObj[name]; + Object.defineProperty(aObj, name, { + get() { + return realFunc.bind(this); + }, + }); + } +} + +bindMethods(MessageScenarioFactory.prototype); diff --git a/comm/mailnews/test/resources/MessageInjection.jsm b/comm/mailnews/test/resources/MessageInjection.jsm new file mode 100644 index 0000000000..9e1b7c79cb --- /dev/null +++ b/comm/mailnews/test/resources/MessageInjection.jsm @@ -0,0 +1,987 @@ +/* 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/. */ + +const EXPORTED_SYMBOLS = ["MessageInjection"]; + +var { mailTestUtils } = ChromeUtils.import( + "resource://testing-common/mailnews/MailTestUtils.jsm" +); +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); +var { MailUtils } = ChromeUtils.import("resource:///modules/MailUtils.jsm"); +var { SyntheticMessageSet } = ChromeUtils.import( + "resource://testing-common/mailnews/MessageGenerator.jsm" +); +var { PromiseTestUtils } = ChromeUtils.import( + "resource://testing-common/mailnews/PromiseTestUtils.jsm" +); +var { VirtualFolderHelper } = ChromeUtils.import( + "resource:///modules/VirtualFolderWrapper.jsm" +); +var { ImapMessage } = ChromeUtils.import( + "resource://testing-common/mailnews/Imapd.jsm" +); +var { IMAPPump, setupIMAPPump } = ChromeUtils.import( + "resource://testing-common/mailnews/IMAPpump.jsm" +); + +const SEARCH_TERM_MAP_HELPER = { + subject: Ci.nsMsgSearchAttrib.Subject, + body: Ci.nsMsgSearchAttrib.Body, + from: Ci.nsMsgSearchAttrib.Sender, + to: Ci.nsMsgSearchAttrib.To, + cc: Ci.nsMsgSearchAttrib.CC, + recipient: Ci.nsMsgSearchAttrib.ToOrCC, + involves: Ci.nsMsgSearchAttrib.AllAddresses, + age: Ci.nsMsgSearchAttrib.AgeInDays, + tags: Ci.nsMsgSearchAttrib.Keywords, + // If a test uses a custom search term, they must register that term + // with the id "mailnews@mozilla.org#test" + custom: Ci.nsMsgSearchAttrib.Custom, +}; + +/** + * Handling for Messages in Folders. Usage of either `local` or `imap`. + * + * Beware: + * Currently only one active instance of MessageInjection is supported due + * to a dependency on retrieving an account in the constructor. + */ +class MessageInjection { + /** + * MessageInjectionSetup + */ + _mis = { + _nextUniqueFolderId: 0, + + injectionConfig: { + mode: "none", + }, + listeners: [], + notifyListeners(handlerName, args) { + for (let listener of this.listeners) { + if (handlerName in listener) { + listener[handlerName].apply(listener, args); + } + } + }, + + /** + * The nsIMsgIncomingServer + */ + incomingServer: null, + + /** + * The incoming server's (synthetic) root message folder. + */ + rootFolder: null, + + /** + * The nsIMsgFolder that is the inbox. + */ + inboxFolder: null, + + /** + * Fakeserver daemon, if applicable. + */ + daemon: null, + /** + * Fakeserver server instance, if applicable. + */ + server: null, + }; + /** + * Creates an environment for tests. + * Usage either with "local" or "imap". + * An Inbox folder is created. Retrieve it via `getInboxFolder` + * + * IMAP: + * Starts an IMAP Server for you + * + * @param {object} injectionConfig + * @param {"local"|"imap"} injectionConfig.mode mode One of "local", "imap". + * @param {boolean} [injectionConfig.offline] Should the folder be marked offline (and + * fully downloaded)? Only relevant for IMAP. + * @param {MessageGenerator} [msgGen] The MessageGenerator which generates the new + * SyntheticMessages. We do not create our own because we would lose track of + * messages created from another MessageGenerator. + * It's optional as it is used only for a subset of methods. + */ + constructor(injectionConfig, msgGen) { + // Set the injection Mode. + this._mis.injectionConfig = injectionConfig; + + // Disable new mail notifications. + Services.prefs.setBoolPref("mail.biff.play_sound", false); + Services.prefs.setBoolPref("mail.biff.show_alert", false); + Services.prefs.setBoolPref("mail.biff.show_tray_icon", false); + Services.prefs.setBoolPref("mail.biff.animate_dock_icon", false); + + // Set msgGen if given. + if (msgGen) { + this.msgGen = msgGen; + } + + // we need to pull in the notification service so we get events? + MailServices.mfn; + + if (this._mis.injectionConfig.mode == "local") { + // This does createIncomingServer() and createAccount(), sets the server as + // the account's server, then sets the server. + try { + MailServices.accounts.createLocalMailAccount(); + } catch (ex) { + // This will fail if someone already called this. Like in the mozmill + // case. + } + + let localAccount = MailServices.accounts.FindAccountForServer( + MailServices.accounts.localFoldersServer + ); + + // We need an identity or we get angry warnings. + let identity = MailServices.accounts.createIdentity(); + // We need an email to protect against random code assuming it exists and + // throwing exceptions. + identity.email = "sender@nul.invalid"; + localAccount.addIdentity(identity); + localAccount.defaultIdentity = identity; + + this._mis.incomingServer = MailServices.accounts.localFoldersServer; + // Note: Inbox is not created automatically when there is no deferred server, + // so we need to create it. + this._mis.rootFolder = this._mis.incomingServer.rootMsgFolder; + this._mis.rootFolder.createSubfolder("Inbox", null); + this._mis.inboxFolder = this._mis.rootFolder.getChildNamed("Inbox"); + // a local inbox should have a Mail flag! + this._mis.inboxFolder.setFlag(Ci.nsMsgFolderFlags.Mail); + this._mis.inboxFolder.setFlag(Ci.nsMsgFolderFlags.Inbox); + this._mis.notifyListeners("onRealFolderCreated", [this._mis.inboxFolder]); + + // Force an initialization of the Inbox folder database. + this._mis.inboxFolder.prettyName; + } else if (this._mis.injectionConfig.mode == "imap") { + // Disable autosync in favor of our explicitly forcing downloads of all + // messages in a folder. This is being done speculatively because when we + // didn't do this we got tripped up by the semaphore being in use and + // concern over inability to hang a listener off of the completion of the + // download. (Although I'm sure there are various ways we could do it.) + Services.prefs.setBoolPref( + "mail.server.default.autosync_offline_stores", + false + ); + // Set the offline property based on the configured setting. This will + // affect newly created folders. + Services.prefs.setBoolPref( + "mail.server.default.offline_download", + this._mis.injectionConfig.offline + ); + + // set up IMAP fakeserver and incoming server + setupIMAPPump(""); + this._mis.daemon = IMAPPump.daemon; + this._mis.server = IMAPPump.server; + this._mis.incomingServer = IMAPPump.incomingServer; + // this.#mis.server._debug = 3; + + // do not log transactions; it's just a memory leak to us + this._mis.server._logTransactions = false; + + // We need an identity so that updateFolder doesn't fail + let localAccount = MailServices.accounts.defaultAccount; + // We need an email to protect against random code assuming it exists and + // throwing exceptions. + let identity = localAccount.defaultIdentity; + identity.email = "sender@nul.invalid"; + + // The server doesn't support more than one connection + Services.prefs.setIntPref( + "mail.server.server1.max_cached_connections", + 1 + ); + // We aren't interested in downloading messages automatically + Services.prefs.setBoolPref("mail.server.server1.download_on_biff", false); + + this._mis.rootFolder = this._mis.incomingServer.rootMsgFolder; + + this._mis.inboxFolder = this._mis.rootFolder.getChildNamed("Inbox"); + // make sure the inbox's offline state is correct. (may be excessive now + // that we set the pref above?) + if (this._mis.injectionConfig.offline) { + this._mis.inboxFolder.setFlag(Ci.nsMsgFolderFlags.Offline); + } else { + this._mis.inboxFolder.clearFlag(Ci.nsMsgFolderFlags.Offline); + } + this._mis.notifyListeners("onRealFolderCreated", [this._mis.inboxFolder]); + + this._mis.handleUriToRealFolder = {}; + this._mis.handleUriToFakeFolder = {}; + this._mis.realUriToFakeFolder = {}; + this._mis.realUriToFakeFolder[this._mis.inboxFolder.URI] = + this._mis.daemon.getMailbox("INBOX"); + } else { + throw new Error( + "Illegal injection config option: " + this._mis.injectionConfig.mode + ); + } + + this._mis.junkHandle = null; + this._mis.junkFolder = null; + + this._mis.trashHandle = null; + this._mis.trashFolder = null; + } + + /** + * @returns {nsIMsgFolder} + */ + getInboxFolder() { + return this._mis.inboxFolder; + } + /** + * @returns {boolean} + */ + messageInjectionIsLocal() { + return this._mis.injectionConfig.mode == "local"; + } + /** + * Call this method to finish the use of MessageInjection. + * Stops the IMAP server (if used) and stops internal functions. + */ + teardownMessageInjection() { + if (this._mis.injectionConfig.mode == "imap") { + this._mis.incomingServer.closeCachedConnections(); + + // No more tests, let everything finish. + // (This spins its own event loop...) + this._mis.server.stop(); + } + + // Clean out this.#mis; we don't just null the global because it's conceivable we + // might still have some closures floating about. + for (let key in this._mis) { + delete this._mis[key]; + } + } + /** + * Register a listener to be notified when interesting things happen involving + * calls made to the message injection API. + * + * @param {object} listener + * @param {Function} listener.onVirtualFolderCreated Called when a virtual + * folder is created using |makeVirtualFolder|. Takes a nsIMsgFolder + * that defines the virtual folder as argument. + */ + registerMessageInjectionListener(listener) { + this._mis.listeners.push(listener); + } + /** + * Create and return an empty folder. If you want to delete this folder + * you must call |deleteFolder| to kill it! If you want to rename it, you + * must implement a method called renameFolder and then call it. + * + * @param {string} [folderName] A folder name with no support for hierarchy at this + * time. A name of the form "gabba#" will be autogenerated if you do not + * provide one. + * @param {nsMsgFolderFlags[]} [specialFlags] A list of nsMsgFolderFlags bits to set. + * @returns {nsIMsgFolder|string} In local mode a nsIMsgFolder is returned. + * In imap mode a folder URI is returned. + */ + async makeEmptyFolder(folderName, specialFlags) { + if (folderName == null) { + folderName = "gabba" + this._mis._nextUniqueFolderId++; + } + let testFolder; + + if (this._mis.injectionConfig.mode == "local") { + let localRoot = this._mis.rootFolder.QueryInterface( + Ci.nsIMsgLocalMailFolder + ); + testFolder = localRoot.createLocalSubfolder(folderName); + // it seems dumb that we have to set this. + testFolder.setFlag(Ci.nsMsgFolderFlags.Mail); + if (specialFlags) { + for (let flag of specialFlags) { + testFolder.setFlag(flag); + } + } + this._mis.notifyListeners("onRealFolderCreated", [testFolder]); + } else if (this._mis.injectionConfig.mode == "imap") { + // Circumvent this scoping. + let mis = this._mis; + let promiseUrlListener = new PromiseTestUtils.PromiseUrlListener({ + OnStopRunningUrl: (url, exitCode) => { + // get the newly created nsIMsgFolder folder + let msgFolder = mis.rootFolder.getChildNamed(folderName); + + // XXX there is a bug that causes folders to be reported as ImapPublic + // when there is no namespace support by the IMAP server. This is + // a temporary workaround. + msgFolder.clearFlag(Ci.nsMsgFolderFlags.ImapPublic); + msgFolder.setFlag(Ci.nsMsgFolderFlags.ImapPersonal); + + if (specialFlags) { + for (let flag of specialFlags) { + msgFolder.setFlag(flag); + } + } + + // get a reference to the fake server folder + let fakeFolder = this._mis.daemon.getMailbox(folderName); + // establish the mapping + mis.handleUriToRealFolder[testFolder] = msgFolder; + mis.handleUriToFakeFolder[testFolder] = fakeFolder; + mis.realUriToFakeFolder[msgFolder.URI] = fakeFolder; + + // notify listeners + mis.notifyListeners("onRealFolderCreated", [msgFolder]); + }, + }); + + testFolder = this._mis.rootFolder.URI + "/" + folderName; + + // Tell the IMAP service to create the folder, adding a listener that + // hooks up the 'handle' URI -> actual folder mapping. + MailServices.imap.createFolder( + this._mis.rootFolder, + folderName, + promiseUrlListener + ); + await promiseUrlListener.promise; + } + + return testFolder; + } + /** + * Small helper for moving folder. + * + * @param {nsIMsgFolder} source + * @param {nsIMsgFolder} target + */ + static async moveFolder(source, target) { + // we're doing a true move + await new Promise((resolve, reject) => { + MailServices.copy.copyFolder( + MessageInjection.get_nsIMsgFolder(source), + MessageInjection.get_nsIMsgFolder(target), + true, + { + /* nsIMsgCopyServiceListener implementation */ + OnStartCopy() {}, + OnProgress(progress, progressMax) {}, + SetMessageKey(key) {}, + SetMessageId(messageId) {}, + OnStopCopy(status) { + if (Components.isSuccessCode(status)) { + resolve(); + } else { + reject(); + } + }, + }, + null + ); + }); + } + /** + * + * Get/create the junk folder handle. Use getRealInjectionFolder if you + * need the underlying nsIFolder. + * + * @returns {nsIMsgFolder} + */ + async getJunkFolder() { + if (!this._mis.junkHandle) { + this._mis.junkHandle = await this.makeEmptyFolder("Junk", [ + Ci.nsMsgFolderFlags.Junk, + ]); + } + + return this._mis.junkHandle; + } + /** + * Get/create the trash folder handle. Use getRealInjectionFolder if you + * need the underlying nsIMsgFolder. + * + * @returns {nsIMsgFolder|string} + */ + async getTrashFolder() { + if (!this._mis.trashHandle) { + // the folder may have been created and already known... + this._mis.trashFolder = this._mis.rootFolder.getFolderWithFlags( + Ci.nsMsgFolderFlags.Trash + ); + if (this._mis.trashFolder) { + this._mis.trashHandle = this._mis.rootFolder.URI + "/Trash"; + let fakeFolder = this._mis.daemon.getMailbox("Trash"); + this._mis.handleUriToRealFolder[this._mis.trashHandle] = + this._mis.trashFolder; + this._mis.handleUriToFakeFolder[this._mis.trashHandle] = fakeFolder; + this._mis.realUriToFakeFolder[this._mis.trashFolder.URI] = fakeFolder; + } else { + this._mis.trashHandle = await this.makeEmptyFolder("Trash", [ + Ci.nsMsgFolderFlags.Trash, + ]); + } + } + + return this._mis.trashHandle; + } + /** + * Create and return a virtual folder. + * + * @param {nsIMsgFolder[]} folders The real folders this virtual folder should draw from. + * @param {SEARCH_TERM_MAP_HELPER} searchDef The search definition to use + * to build the list of search terms that populate this virtual folder. + * Keys should be stuff from SEARCH_TERM_MAP_HELPER and values should be + * strings to search for within those attribute things. + * @param {boolean} [booleanAnd] Should the search terms be and-ed together. + * Defaults to false. + * @param {string} [folderName] Name to use. + * @returns {nsIMsgFolder|string} In local usage returns a nsIMsgFolder + * in imap usage returns a Folder URI. + */ + makeVirtualFolder(folders, searchDef, booleanAnd, folderName) { + let name = folderName + ? folderName + : "virt" + this._mis._nextUniqueFolderId++; + + let terms = []; + let termCreator = Cc[ + "@mozilla.org/messenger/searchSession;1" + ].createInstance(Ci.nsIMsgSearchSession); + for (let key in searchDef) { + let val = searchDef[key]; + let term = termCreator.createTerm(); + let value = term.value; + value.str = val; + term.value = value; + term.attrib = SEARCH_TERM_MAP_HELPER[key]; + if (term.attrib == Ci.nsMsgSearchAttrib.Custom) { + term.customId = "mailnews@mozilla.org#test"; + } + term.op = Ci.nsMsgSearchOp.Contains; + term.booleanAnd = Boolean(booleanAnd); + terms.push(term); + } + // create an ALL case if we didn't add any terms + if (terms.length == 0) { + let term = termCreator.createTerm(); + term.matchAll = true; + terms.push(term); + } + + let wrapped = VirtualFolderHelper.createNewVirtualFolder( + name, + this._mis.rootFolder, + folders, + terms, + /* online */ false + ); + this._mis.notifyListeners("onVirtualFolderCreated", [ + wrapped.virtualFolder, + ]); + return wrapped.virtualFolder; + } + /** + * Mark the folder as offline and force all of its messages to be downloaded. + * This is an asynchronous operation that will call resolve once the + * download is completed. + * + * @param {string} folderHandle Folder URI. + */ + async makeFolderAndContentsOffline(folderHandle) { + if (this._mis.injectionConfig.mode != "imap") { + return; + } + + let msgFolder = this.getRealInjectionFolder(folderHandle); + msgFolder.setFlag(Ci.nsMsgFolderFlags.Offline); + let promiseUrlListener = new PromiseTestUtils.PromiseUrlListener(); + msgFolder.downloadAllForOffline(promiseUrlListener, null); + await promiseUrlListener.promise; + } + + /** + * Create multiple new local folders, populating them with messages according to + * the set definitions provided. Differs from makeFolderWithSets by taking + * the number of folders to create and return the list of created folders as + * the first element in the returned list. This method is simple enough that + * the limited code duplication is deemed acceptable in support of readability. + * + * @param {number} folderCount + * @param {MakeMessageOptions[]} synSetDefs A synthetic set + * definition, as appropriate to pass to makeNewSetsInFolders. + * @returns {Promise} A Promise with a list whose first element are + * the nsIMsgFolders created and whose subsequent items are the + * SyntheticMessageSets used to populate the folder (as returned by + * makeNewSetsInFolders). So nsIMsgFolder[], ...SyntheticMessageSet. + * + * Please note that the folders are either nsIMsgFolder, or folder + * URIs, depending on whether we're in local injection mode, or on IMAP. This + * should be transparent to you, unless you start trying to inject messages + * into a folder that hasn't been created by makeFoldersWithSets. See + * test_folder_deletion_nested in base_index_messages.js for an example of + * such pain. + */ + async makeFoldersWithSets(folderCount, synSetDefs) { + let msgFolders = []; + for (let i = 0; i < folderCount; i++) { + msgFolders.push(await this.makeEmptyFolder()); + } + let results = await this.makeNewSetsInFolders(msgFolders, synSetDefs); + // results may be referenced by addSetsToFolders in an async fashion, so + // don't change it. + results = results.concat(); + results.unshift(msgFolders); + return results; + } + /** + * Given one or more existing folders, create new message sets and + * add them to the folders using. + * + * @param {nsIMsgFolder[]} msgFolders A list of nsIMsgFolder. + * The synthetic messages will be added to the folder(s). + * @param {MakeMessageOptions[]} synSetDefs A list of set definition objects as + * defined by MessageGenerator.makeMessages. + * @param {boolean} [doNotForceUpdate=false] By default we force an updateFolder on IMAP + * folders to ensure Thunderbird knows about the newly injected messages. + * If you are testing Thunderbird's use of updateFolder itself, you will + * not want this and so will want to pass true for this argument. + * @returns {SyntheticMessageSet[]} A Promise with a list of SyntheticMessageSet objects, + * each corresponding to the entry in synSetDefs (or implied if an integer was passed). + */ + async makeNewSetsInFolders(msgFolders, synSetDefs, doNotForceUpdate) { + // - create the synthetic message sets + let messageSets = []; + for (let synSetDef of synSetDefs) { + // Using the getter of the MessageGenerator for error handling. + let messages = this.messageGenerator.makeMessages(synSetDef); + messageSets.push(new SyntheticMessageSet(messages)); + } + + // - add the messages to the folders (interleaving them) + await this.addSetsToFolders(msgFolders, messageSets, doNotForceUpdate); + + return messageSets; + } + /** + * Spreads the messages in messageSets across the folders in msgFolders. Each + * message set is spread in a round-robin fashion across all folders. At the + * same time, each message-sets insertion is interleaved with the other message + * sets. This distributes message across multiple folders for useful + * cross-folder threading testing (via the round robin) while also hopefully + * avoiding making things pathologically easy for the code under test (by way + * of the interleaving.) + * + * For example, given the following 2 input message sets: + * message set 'lower': [a b c d e f] + * message set 'upper': [A B C D E F G H] + * + * across 2 folders: + * folder 1: [a A c C e E G] + * folder 2: [b B d D f F H] + * across 3 folders: + * folder 1: [a A d D G] + * folder 2: [b B e E H] + * folder 3: [c C f F] + * + * @param {nsIMsgFolder[]} msgFolders + * An nsIMsgFolder to add the message sets to or a list of them. + * @param {SyntheticMessageSet[]} messageSets A list of SyntheticMessageSets. + * @param {boolean} [doNotForceUpdate=false] By default we force an updateFolder on IMAP + * folders to ensure Thunderbird knows about the newly injected messages. + * If you are testing Thunderbird's use of updateFolder itself, you will + * not want this and so will want to pass true for this argument. + */ + async addSetsToFolders(msgFolders, messageSets, doNotForceUpdate) { + let iterFolders; + + this._mis.notifyListeners("onInjectingMessages", []); + + // -- Pre-loop + if (this._mis.injectionConfig.mode == "local") { + for (let folder of msgFolders) { + if (!(folder instanceof Ci.nsIMsgLocalMailFolder)) { + throw new Error("All folders in msgFolders must be local folders!"); + } + } + } else if (this._mis.injectionConfig.mode == "imap") { + // no protection is possible because of our dependency on promises, + // although we could check that the fake URL is one we handed out. + } else { + throw new Error("Message injection is not configured!"); + } + + if (this._mis.injectionConfig.mode == "local") { + // Note: in order to cut down on excessive fsync()s, we do a two-pass + // approach. In the first pass we just allocate messages to the folder + // we are going to insert them into. In the second pass we insert the + // messages into folders in batches and perform any mutations. + let folderBatches = msgFolders.map(folder => { + return { folder, messages: [] }; + }); + iterFolders = this._looperator([...folderBatches.keys()]); + let iPerSet = 0, + folderNext = iterFolders.next(); + + // - allocate messages to folders + // loop, incrementing our subscript until all message sets are out of messages + let didSomething; + do { + didSomething = false; + // for each message set, if it is not out of messages, add the message + for (let messageSet of messageSets) { + if (iPerSet < messageSet.synMessages.length) { + let synMsg = messageSet._trackMessageAddition( + folderBatches[folderNext.value].folder, + iPerSet + ); + folderBatches[folderNext.value].messages.push({ + messageSet, + synMsg, + index: iPerSet, + }); + didSomething = true; + } + } + iPerSet++; + folderNext = iterFolders.next(); + } while (didSomething); + + // - inject messages + for (let folderBatch of folderBatches) { + // it is conceivable some folders might not get any messages, skip them. + if (!folderBatch.messages.length) { + continue; + } + + let folder = folderBatch.folder; + folder.gettingNewMessages = true; + let messageStrings = folderBatch.messages.map(message => + message.synMsg.toMboxString() + ); + folder.addMessageBatch(messageStrings); + + for (let message of folderBatch.messages) { + let synMsgState = message.synMsg.metaState; + // If we need to mark the message as junk grab the header and do so. + if (synMsgState.junk) { + message.messageSet.setJunk( + true, + message.messageSet.getMsgHdr(message.index) + ); + } + if (synMsgState.read) { + // XXX this will generate an event; I'm not sure if we should be + // trying to avoid that or not. This case is really only added + // for IMAP where this makes more sense. + message.messageSet.setRead( + true, + message.messageSet.getMsgHdr(message.index) + ); + } + } + if (folderBatch.messages.length) { + let lastMRUTime = Math.floor( + Number(folderBatch.messages[0].synMsg.date) / 1000 + ); + folder.setStringProperty("MRUTime", lastMRUTime); + } + folder.gettingNewMessages = false; + folder.hasNewMessages = true; + folder.setNumNewMessages( + folder.getNumNewMessages(false) + messageStrings.length + ); + folder.biffState = Ci.nsIMsgFolder.nsMsgBiffState_NewMail; + } + + // make sure that junk filtering gets a turn + // XXX we probably need to be doing more in terms of filters here, + // although since filters really want to be run on the inbox, there + // are separate potential semantic issues involved. + for (let folder of msgFolders) { + folder.callFilterPlugins(null); + } + } else if (this._mis.injectionConfig.mode == "imap") { + iterFolders = this._looperator(msgFolders); + // we need to call updateFolder on all the folders, not just the first + // one... + let iPerSet = 0, + folder = iterFolders.next(); + let didSomething; + do { + didSomething = false; + for (let messageSet of messageSets) { + if (iPerSet < messageSet.synMessages.length) { + didSomething = true; + + let realFolder = this._mis.handleUriToRealFolder[folder.value]; + let fakeFolder = this._mis.handleUriToFakeFolder[folder.value]; + let synMsg = messageSet._trackMessageAddition(realFolder, iPerSet); + let msgURI = Services.io.newURI( + "data:text/plain;base64," + btoa(synMsg.toMessageString()) + ); + let imapMsg = new ImapMessage( + msgURI.spec, + fakeFolder.uidnext++, + [] + ); + // If the message's meta-state indicates it is junk, set that flag. + // There is also a NotJunk flag, but we're not playing with that + // right now; as long as nothing is ever marked as junk, the junk + // classifier won't run, so it's moot for now. + if (synMsg.metaState.junk) { + imapMsg.setFlag("Junk"); + } + if (synMsg.metaState.read) { + imapMsg.setFlag("\\Seen"); + } + fakeFolder.addMessage(imapMsg); + } + } + iPerSet++; + folder = iterFolders.next(); + } while (didSomething); + + // We have nothing more to do if we aren't support to force the update. + if (doNotForceUpdate) { + return; + } + + for (let iFolder = 0; iFolder < msgFolders.length; iFolder++) { + let realFolder = this._mis.handleUriToRealFolder[msgFolders[iFolder]]; + await new Promise(resolve => { + mailTestUtils.updateFolderAndNotify(realFolder, resolve); + }); + + // compel download of the messages if appropriate + if (realFolder.flags & Ci.nsMsgFolderFlags.Offline) { + let promiseUrlListener = new PromiseTestUtils.PromiseUrlListener(); + realFolder.downloadAllForOffline(promiseUrlListener, null); + await promiseUrlListener.promise; + } + } + } + } + /** + * Return the nsIMsgFolder associated with a folder handle. If the folder has + * been created since the last injection and you are using IMAP, you may need + * to first resolve the Promises for us to be able to provide + * you with a result. + * + * @param {nsIMsgFolder|string} folderHandle nsIMsgFolder or folder URI. + * @returns {nsIMsgFolder} + */ + getRealInjectionFolder(folderHandle) { + if (this._mis.injectionConfig.mode == "imap") { + return this._mis.handleUriToRealFolder[folderHandle]; + } + return folderHandle; + } + /** + * Move messages in the given set to the destination folder. + * + * For IMAP moves we force an update of the source folder and then the + * destination folder. This ensures that any (pseudo-)offline operations in + * the source folder have had a chance to run and that we have seen the changes + * in the target folder. + * We additionally cause all of the message bodies to be downloaded in the + * target folder if the folder has the Offline flag set. + * + * @param {SyntheticMessageSet} synMessageSet The messages to move. + * @param {nsIMsgFolder|string} destFolder The target folder or target folder URI. + * @param {boolean} [allowUndo=false] Should we generate undo operations and, as a + * side-effect, offline operations? (The code uses undo operations as + * a proxy-indicator for it coming from the UI and therefore performing + * pseudo-offline operations instead of trying to do things online.) + */ + async moveMessages(synMessageSet, destFolder, allowUndo) { + let realDestFolder = this.getRealInjectionFolder(destFolder); + + for (let [folder, msgs] of synMessageSet.foldersWithMsgHdrs) { + // In the IMAP case tell listeners we are moving messages without + // destination headers. + if (!this.messageInjectionIsLocal()) { + this._mis.notifyListeners("onMovingMessagesWithoutDestHeaders", [ + realDestFolder, + ]); + } + let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener(); + MailServices.copy.copyMessages( + folder, + msgs, + realDestFolder, + /* move */ true, + promiseCopyListener, + null, + Boolean(allowUndo) + ); + await promiseCopyListener.promise; + // update the synthetic message set's folder entry... + synMessageSet._folderSwap(folder, realDestFolder); + + // IMAP special case per function doc... + if (!this.messageInjectionIsLocal()) { + // update the source folder to force it to issue the move + await new Promise(resolve => { + mailTestUtils.updateFolderAndNotify(folder, resolve); + }); + + // update the dest folder to see the new header. + await new Promise(resolve => { + mailTestUtils.updateFolderAndNotify(realDestFolder, resolve); + }); + + // compel download of messages in dest folder if appropriate + if (realDestFolder.flags & Ci.nsMsgFolderFlags.Offline) { + let promiseUrlListener = new PromiseTestUtils.PromiseUrlListener(); + realDestFolder.downloadAllForOffline(promiseUrlListener, null); + await promiseUrlListener.promise; + } + } + } + } + /** + * Move the messages to the trash; do not use this on messages that are already + * in the trash, we are not clever enough for that. + * + * @param {SyntheticMessageSet} synMessageSet The set of messages to trash. + * The messages do not all have to be in the same folder, + * but we have to trash them folder by folder if they are not. + */ + async trashMessages(synMessageSet) { + for (let [folder, msgs] of synMessageSet.foldersWithMsgHdrs) { + // In the IMAP case tell listeners we are moving messages without + // destination headers, since that's what trashing amounts to. + if (!this.messageInjectionIsLocal()) { + this._mis.notifyListeners("onMovingMessagesWithoutDestHeaders", []); + } + let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener(); + folder.deleteMessages( + msgs, + null, + false, + true, + promiseCopyListener, + /* do not allow undo, currently leaks */ false + ); + await promiseCopyListener.promise; + + // just like the move case we need to force updateFolder calls for IMAP + if (!this.messageInjectionIsLocal()) { + // update the source folder to force it to issue the move + await new Promise(resolve => { + mailTestUtils.updateFolderAndNotify(folder, resolve); + }); + + // trash folder may not have existed at startup but the deletion + // will have created it. + let trashFolder = this.getRealInjectionFolder( + await this.getTrashFolder() + ); + + // update the dest folder to see the new header. + await new Promise(resolve => { + mailTestUtils.updateFolderAndNotify(trashFolder, resolve); + }); + + // compel download of messages in dest folder if appropriate + if (trashFolder.flags & Ci.nsMsgFolderFlags.Offline) { + let promiseUrlListener = new PromiseTestUtils.PromiseUrlListener(); + trashFolder.downloadAllForOffline(promiseUrlListener, null); + await promiseUrlListener.promise; + } + } + } + } + /** + * Delete all of the messages in a SyntheticMessageSet like the user performed a + * shift-delete (or if the messages were already in the trash). + * + * @param {SyntheticMessageSet} synMessageSet 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. + */ + static async deleteMessages(synMessageSet) { + for (let [folder, msgs] of synMessageSet.foldersWithMsgHdrs) { + let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener(); + folder.deleteMessages( + msgs, + null, + /* delete storage */ true, + /* is move? */ false, + promiseCopyListener, + /* do not allow undo, currently leaks */ false + ); + await promiseCopyListener.promise; + } + } + /** + * Empty the trash. + */ + async emptyTrash() { + let trashHandle = await this.getTrashFolder(); + let trashFolder = this.getRealInjectionFolder(trashHandle); + let promiseUrlListener = new PromiseTestUtils.PromiseUrlListener(); + trashFolder.emptyTrash(promiseUrlListener); + await promiseUrlListener.promise; + } + /** + * Delete the given folder, removing the storage. We do not move it to the + * trash. + */ + deleteFolder(folder) { + let realFolder = this.getRealInjectionFolder(folder); + realFolder.parent.propagateDelete(realFolder, true); + } + + /** + * @param {nsIMsgFolder} folder + * @returns {nsIMsgFolder} + */ + static get_nsIMsgFolder(folder) { + if (!(folder instanceof Ci.nsIMsgFolder)) { + return MailUtils.getOrCreateFolder(folder); + } + return folder; + } + /** + * An iterator that generates an infinite sequence of its argument. So + * _looperator(1, 2, 3) will generate the iteration stream: [1, 2, 3, 1, 2, 3, + * 1, 2, 3, ...]. + */ + *_looperator(list) { + if (list.length == 0) { + throw new Error("list must have at least one item!"); + } + + let i = 0, + length = list.length; + while (true) { + yield list[i]; + i = (i + 1) % length; + } + } + + get messageGenerator() { + if (this.msgGen === undefined) { + throw new Error( + "MessageInjection.jsm needs a MessageGenerator for new messages. " + + "The MessageGenerator helps you with threaded messages. If you use " + + "two different MessageGenerators the behaviour with threads are complicated." + ); + } + return this.msgGen; + } + /** + * @param {MessageGenerator} msgGen The MessageGenerator which generates the new + * SyntheticMessages. We do not create our own because we would lose track of + * messages created from another MessageGenerator. + */ + set messageGenerator(msgGen) { + this.msgGen = msgGen; + } +} diff --git a/comm/mailnews/test/resources/NetworkTestUtils.jsm b/comm/mailnews/test/resources/NetworkTestUtils.jsm new file mode 100644 index 0000000000..131eb9c9eb --- /dev/null +++ b/comm/mailnews/test/resources/NetworkTestUtils.jsm @@ -0,0 +1,294 @@ +/* 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/. */ + +/** + * This file provides utilities useful in testing more advanced networking + * scenarios, such as proxies and SSL connections. + */ + +const EXPORTED_SYMBOLS = ["NetworkTestUtils"]; + +var CC = Components.Constructor; + +const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm"); + +const ServerSocket = CC( + "@mozilla.org/network/server-socket;1", + "nsIServerSocket", + "init" +); +const BinaryInputStream = CC( + "@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream" +); + +// The following code is adapted from network/test/unit/test_socks.js, in order +// to provide a SOCKS proxy server for our testing code. +// +// For more details on how SOCKSv5 works, please read RFC 1928. +var currentThread = Services.tm.currentThread; + +const STATE_WAIT_GREETING = 1; +const STATE_WAIT_SOCKS5_REQUEST = 2; + +/** + * A client of a SOCKS connection. + * + * This doesn't implement all of SOCKSv5, just enough to get a simple proxy + * working for the test code. + * + * @param {nsIInputStream} client_in - The nsIInputStream of the socket. + * @param {nsIOutputStream} client_out - The nsIOutputStream of the socket. + */ +function SocksClient(client_in, client_out) { + this.client_in = client_in; + this.client_out = client_out; + this.inbuf = []; + this.state = STATE_WAIT_GREETING; + this.waitRead(this.client_in); +} +SocksClient.prototype = { + // ... implement nsIInputStreamCallback ... + QueryInterface: ChromeUtils.generateQI(["nsIInputStreamCallback"]), + onInputStreamReady(input) { + var len = input.available(); + var bin = new BinaryInputStream(input); + var data = bin.readByteArray(len); + this.inbuf = this.inbuf.concat(data); + + switch (this.state) { + case STATE_WAIT_GREETING: + this.handleGreeting(); + break; + case STATE_WAIT_SOCKS5_REQUEST: + this.handleSocks5Request(); + break; + } + + if (!this.sub_transport) { + this.waitRead(input); + } + }, + + // Listen on the input for the next packet + waitRead(input) { + input.asyncWait(this, 0, 0, currentThread); + }, + + // Simple handler to write out a binary string (because xpidl sucks here) + write(buf) { + this.client_out.write(buf, buf.length); + }, + + // Handle the first SOCKSv5 client message + handleGreeting() { + if (this.inbuf.length == 0) { + return; + } + + if (this.inbuf[0] != 5) { + dump("Unknown protocol version: " + this.inbuf[0] + "\n"); + this.close(); + return; + } + + // Some quality checks to make sure we've read the entire greeting. + if (this.inbuf.length < 2) { + return; + } + var nmethods = this.inbuf[1]; + if (this.inbuf.length < 2 + nmethods) { + return; + } + this.inbuf = []; + + // Tell them that we don't log into this SOCKS server. + this.state = STATE_WAIT_SOCKS5_REQUEST; + this.write("\x05\x00"); + }, + + // Handle the second SOCKSv5 message + handleSocks5Request() { + if (this.inbuf.length < 4) { + return; + } + + // Find the address:port requested. + var atype = this.inbuf[3]; + var len, addr; + if (atype == 0x01) { + // IPv4 Address + len = 4; + addr = this.inbuf.slice(4, 8).join("."); + } else if (atype == 0x03) { + // Domain name + len = this.inbuf[4]; + addr = String.fromCharCode.apply(null, this.inbuf.slice(5, 5 + len)); + len = len + 1; + } else if (atype == 0x04) { + // IPv6 address + len = 16; + addr = this.inbuf + .slice(4, 20) + .map(i => i.toString(16)) + .join(":"); + } + var port = (this.inbuf[4 + len] << 8) | this.inbuf[5 + len]; + dump("Requesting " + addr + ":" + port + "\n"); + + // Map that data to the port we report. + var foundPort = gPortMap.get(addr + ":" + port); + dump("This was mapped to " + foundPort + "\n"); + + if (foundPort !== undefined) { + this.write( + "\x05\x00\x00" + // Header for response + "\x04" + + "\x00".repeat(15) + + "\x01" + // IPv6 address ::1 + String.fromCharCode(foundPort >> 8) + + String.fromCharCode(foundPort & 0xff) // Port number + ); + } else { + this.write( + "\x05\x05\x00" + // Header for failed response + "\x04" + + "\x00".repeat(15) + + "\x01" + // IPv6 address ::1 + "\x00\x00" + ); + this.close(); + return; + } + + // At this point, we contact the local server on that port and then we feed + // the data back and forth. Easiest way to do that is to open the connection + // and use the async copy to do it in a background thread. + let sts = Cc["@mozilla.org/network/socket-transport-service;1"].getService( + Ci.nsISocketTransportService + ); + let trans = sts.createTransport([], "localhost", foundPort, null, null); + let tunnelInput = trans.openInputStream(0, 1024, 1024); + let tunnelOutput = trans.openOutputStream(0, 1024, 1024); + this.sub_transport = trans; + NetUtil.asyncCopy(tunnelInput, this.client_out); + NetUtil.asyncCopy(this.client_in, tunnelOutput); + }, + + close() { + this.client_in.close(); + this.client_out.close(); + if (this.sub_transport) { + this.sub_transport.close(Cr.NS_OK); + } + }, +}; + +// A SOCKS server that runs on a random port. +function SocksTestServer() { + this.listener = ServerSocket(-1, true, -1); + dump("Starting SOCKS server on " + this.listener.port + "\n"); + this.port = this.listener.port; + this.listener.asyncListen(this); + this.client_connections = []; +} +SocksTestServer.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIServerSocketListener"]), + + onSocketAccepted(socket, trans) { + var input = trans.openInputStream(0, 0, 0); + var output = trans.openOutputStream(0, 0, 0); + var client = new SocksClient(input, output); + this.client_connections.push(client); + }, + + onStopListening(socket) {}, + + close() { + for (let client of this.client_connections) { + client.close(); + } + this.client_connections = []; + if (this.listener) { + this.listener.close(); + this.listener = null; + } + }, +}; + +var gSocksServer = null; +// hostname:port -> the port on localhost that the server really runs on. +var gPortMap = new Map(); + +var NetworkTestUtils = { + /** + * Set up a proxy entry such that requesting a connection to hostName:port + * will instead cause a connection to localRemappedPort. This will use a SOCKS + * proxy (because any other mechanism is too complicated). Since this is + * starting up a server, it does behoove you to call shutdownServers when you + * no longer need to use the proxy server. + * + * @param {string} hostName - The DNS name to use for the client. + * @param {integer} hostPort - The port number to use for the client. + * @param {integer} localRemappedPort - The port number on which the real server sits. + */ + configureProxy(hostName, hostPort, localRemappedPort) { + if (gSocksServer == null) { + gSocksServer = new SocksTestServer(); + // Using PAC makes much more sense here. However, it turns out that PAC + // appears to be broken with synchronous proxy resolve, so enabling the + // PAC mode requires bug 791645 to be fixed first. + /* + let pac = 'data:text/plain,function FindProxyForURL(url, host) {' + + "if (host == 'localhost' || host == '127.0.0.1') {" + + 'return "DIRECT";' + + '}' + + 'return "SOCKS5 127.0.0.1:' + gSocksServer.port + '";' + + '}'; + dump(pac + '\n'); + Services.prefs.setIntPref("network.proxy.type", 2); + Services.prefs.setCharPref("network.proxy.autoconfig_url", pac); + */ + + // Until then, we'll serve the actual proxy via a proxy filter. + let pps = Cc["@mozilla.org/network/protocol-proxy-service;1"].getService( + Ci.nsIProtocolProxyService + ); + let filter = { + QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyFilter"]), + applyFilter(aURI, aProxyInfo, aCallback) { + if (aURI.host != "localhost" && aURI.host != "127.0.0.1") { + aCallback.onProxyFilterResult( + pps.newProxyInfo( + "socks", + "localhost", + gSocksServer.port, + "", + "", + Ci.nsIProxyInfo.TRANSPARENT_PROXY_RESOLVES_HOST, + 0, + null + ) + ); + return; + } + aCallback.onProxyFilterResult(aProxyInfo); + }, + }; + pps.registerFilter(filter, 0); + } + dump("Requesting to map " + hostName + ":" + hostPort + "\n"); + gPortMap.set(hostName + ":" + hostPort, localRemappedPort); + }, + + /** + * Turn off any servers started by this file (e.g., the SOCKS proxy server). + */ + shutdownServers() { + if (gSocksServer) { + gSocksServer.close(); + } + }, +}; diff --git a/comm/mailnews/test/resources/POP3pump.js b/comm/mailnews/test/resources/POP3pump.js new file mode 100644 index 0000000000..5a083798b1 --- /dev/null +++ b/comm/mailnews/test/resources/POP3pump.js @@ -0,0 +1,269 @@ +/* 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/. */ + +/** + * This routine will allow the easy processing of + * messages through the fake POP3 server into the local + * folder. It uses a single global defined as: + * + * gPOP3Pump: the main access to the routine + * gPOP3Pump.run() function to run to load the messages. Returns promise that + * resolves when done. + * gPOP3Pump.files: (in) an array of message files to load + * gPOP3Pump.onDone: function to execute after completion + (optional and deprecated) + * gPOP3Pump.fakeServer: (out) the POP3 incoming server + * gPOP3Pump.resetPluggableStore(): function to change the pluggable store for the + * server to the input parameter's store. + * (in) pluggable store contract ID + * + * adapted from test_pop3GetNewMail.js + * + * Original Author: Kent James + * + */ + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); +var { localAccountUtils } = ChromeUtils.import( + "resource://testing-common/mailnews/LocalAccountUtils.jsm" +); + +// Import the pop3 server scripts +var { nsMailServer } = ChromeUtils.import( + "resource://testing-common/mailnews/Maild.jsm" +); +var { AuthPLAIN, AuthLOGIN, AuthCRAM } = ChromeUtils.import( + "resource://testing-common/mailnews/Auth.jsm" +); +var { + Pop3Daemon, + POP3_RFC1939_handler, + POP3_RFC2449_handler, + POP3_RFC5034_handler, +} = ChromeUtils.import("resource://testing-common/mailnews/Pop3d.jsm"); + +function POP3Pump() { + // public attributes + this.fakeServer = null; + this.onDone = null; + this.files = null; + + // local private variables + + this.kPOP3_PORT = 1024 + 110; + this._server = null; + this._daemon = null; + this._incomingServer = null; + this._firstFile = true; + this._tests = []; + this._finalCleanup = false; + this._expectedResult = Cr.NS_OK; + this._actualResult = Cr.NS_ERROR_UNEXPECTED; + this._mailboxStoreContractID = Services.prefs.getCharPref( + "mail.serverDefaultStoreContractID" + ); +} + +// nsIUrlListener implementation +POP3Pump.prototype.OnStartRunningUrl = function (url) {}; + +POP3Pump.prototype.OnStopRunningUrl = function (aUrl, aResult) { + this._actualResult = aResult; + if (aResult != Cr.NS_OK) { + // If we have an error, clean up nicely. + this._server.stop(); + + var thread = Services.tm.currentThread; + while (thread.hasPendingEvents()) { + thread.processNextEvent(true); + } + } + Assert.equal(aResult, this._expectedResult); + + // Let OnStopRunningUrl return cleanly before doing anything else. + do_timeout(0, _checkPumpBusy); +}; + +// Setup the daemon and server +// If the debugOption is set, then it will be applied to the server. +POP3Pump.prototype._setupServerDaemon = function (aDebugOption) { + this._daemon = new Pop3Daemon(); + function createHandler(d) { + return new POP3_RFC1939_handler(d); + } + this._server = new nsMailServer(createHandler, this._daemon); + if (aDebugOption) { + this._server.setDebugLevel(aDebugOption); + } + return [this._daemon, this._server]; +}; + +POP3Pump.prototype._createPop3ServerAndLocalFolders = function () { + if (typeof localAccountUtils.inboxFolder == "undefined") { + localAccountUtils.loadLocalMailAccount(); + } + + if (!this.fakeServer) { + this.fakeServer = localAccountUtils.create_incoming_server( + "pop3", + this.kPOP3_PORT, + "fred", + "wilma" + ); + } + + return this.fakeServer; +}; + +POP3Pump.prototype.resetPluggableStore = function (aStoreContractID) { + if (aStoreContractID == this._mailboxStoreContractID) { + return; + } + + Services.prefs.setCharPref( + "mail.serverDefaultStoreContractID", + aStoreContractID + ); + + // Cleanup existing files, server and account instances, if any. + if (this._server) { + this._server.stop(); + } + + if (this.fakeServer && this.fakeServer.valid) { + this.fakeServer.closeCachedConnections(); + MailServices.accounts.removeIncomingServer(this.fakeServer, false); + } + + this.fakeServer = null; + localAccountUtils.clearAll(); + + this._incomingServer = this._createPop3ServerAndLocalFolders(); + this._mailboxStoreContractID = aStoreContractID; +}; + +POP3Pump.prototype._checkBusy = function () { + if (this._tests.length == 0 && !this._finalCleanup) { + this._incomingServer.closeCachedConnections(); + + // No more tests, let everything finish + this._server.stop(); + this._finalCleanup = true; + do_timeout(20, _checkPumpBusy); + return; + } + + if (this._finalCleanup) { + if (Services.tm.currentThread.hasPendingEvents()) { + do_timeout(20, _checkPumpBusy); + } else { + // exit this module + do_test_finished(); + if (this.onDone) { + this._promise.then(this.onDone, this.onDone); + } + if (this._actualResult == Cr.NS_OK) { + this._resolve(); + } else { + this._reject(this._actualResult); + } + } + return; + } + + // If the server hasn't quite finished, just delay a little longer. + if (this._incomingServer.serverBusy) { + do_timeout(20, _checkPumpBusy); + return; + } + + this._testNext(); +}; + +POP3Pump.prototype._testNext = function () { + let thisFiles = this._tests.shift(); + if (!thisFiles) { + // Exit. + this._checkBusy(); + } + + // Handle the server in a try/catch/finally loop so that we always will stop + // the server if something fails. + try { + if (this._firstFile) { + this._firstFile = false; + + // Start the fake POP3 server + this._server.start(); + this.kPOP3_PORT = this._server.port; + if (this.fakeServer) { + this.fakeServer.port = this.kPOP3_PORT; + } + } else { + this._server.resetTest(); + } + + // Set up the test + this._daemon.setMessages(thisFiles); + + // Now get the mail, get inbox in case it got un-deferred. + let inbox = this._incomingServer.rootMsgFolder.getFolderWithFlags( + Ci.nsMsgFolderFlags.Inbox + ); + MailServices.pop3.GetNewMail(null, this, inbox, this._incomingServer); + + this._server.performTest(); + } catch (e) { + this._server.stop(); + + do_throw(e); + } +}; + +POP3Pump.prototype.run = function (aExpectedResult) { + do_test_pending(); + // Disable new mail notifications + Services.prefs.setBoolPref("mail.biff.play_sound", false); + Services.prefs.setBoolPref("mail.biff.show_alert", false); + Services.prefs.setBoolPref("mail.biff.show_tray_icon", false); + Services.prefs.setBoolPref("mail.biff.animate_dock_icon", false); + + this._server = this._setupServerDaemon(); + this._daemon = this._server[0]; + this._server = this._server[1]; + + this._firstFile = true; + this._finalCleanup = false; + + if (aExpectedResult) { + this._expectedResult = aExpectedResult; + } + + // In the default configuration, only a single test is accepted + // by this routine. But the infrastructure exists to support + // multiple tests, as this was in the original files. We leave that + // infrastructure in place, so that if desired this routine could + // be easily copied and modified to make multiple passes through + // a POP3 server. + + this._tests[0] = this.files; + + this._testNext(); + + // This probably does not work with multiple tests, but nobody is using that. + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); + return this._promise; +}; + +var gPOP3Pump = new POP3Pump(); +gPOP3Pump._incomingServer = gPOP3Pump._createPop3ServerAndLocalFolders(); + +function _checkPumpBusy() { + gPOP3Pump._checkBusy(); +} diff --git a/comm/mailnews/test/resources/PromiseTestUtils.jsm b/comm/mailnews/test/resources/PromiseTestUtils.jsm new file mode 100644 index 0000000000..cb40b8c856 --- /dev/null +++ b/comm/mailnews/test/resources/PromiseTestUtils.jsm @@ -0,0 +1,316 @@ +/* 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/. */ + +/** + * This file provides utilities useful in using Promises and Task.jsm + * with mailnews tests. + */ + +const EXPORTED_SYMBOLS = ["PromiseTestUtils"]; + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +/** + * Url listener that can wrap another listener and trigger a callback. + * + * @param [aWrapped] The nsIUrlListener to pass all notifications through to. + * This gets called prior to the callback (or async resumption). + */ + +var PromiseTestUtils = {}; + +PromiseTestUtils.PromiseUrlListener = function (aWrapped) { + this.wrapped = aWrapped; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); +}; + +PromiseTestUtils.PromiseUrlListener.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIUrlListener"]), + + OnStartRunningUrl(aUrl) { + if (this.wrapped && this.wrapped.OnStartRunningUrl) { + this.wrapped.OnStartRunningUrl(aUrl); + } + }, + OnStopRunningUrl(aUrl, aExitCode) { + if (this.wrapped && this.wrapped.OnStopRunningUrl) { + this.wrapped.OnStopRunningUrl(aUrl, aExitCode); + } + if (aExitCode == Cr.NS_OK) { + this._resolve(); + } else { + this._reject(aExitCode); + } + }, + get promise() { + return this._promise; + }, +}; + +/** + * Copy listener that can wrap another listener and trigger a callback. + * + * @param {nsIMsgCopyServiceListener} [aWrapped] - The nsIMsgCopyServiceListener + * to pass all notifications through to. This gets called prior to the + * callback (or async resumption). + */ +PromiseTestUtils.PromiseCopyListener = function (aWrapped) { + this.wrapped = aWrapped; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); + this._result = { messageKeys: [], messageIds: [] }; +}; + +PromiseTestUtils.PromiseCopyListener.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIMsgCopyServiceListener"]), + OnStartCopy() { + if (this.wrapped && this.wrapped.OnStartCopy) { + this.wrapped.OnStartCopy(); + } + }, + OnProgress(aProgress, aProgressMax) { + if (this.wrapped && this.wrapped.OnProgress) { + this.wrapped.OnProgress(aProgress, aProgressMax); + } + }, + SetMessageKey(aKey) { + if (this.wrapped && this.wrapped.SetMessageKey) { + this.wrapped.SetMessageKey(aKey); + } + + this._result.messageKeys.push(aKey); + }, + SetMessageId(aMessageId) { + if (this.wrapped && this.wrapped.SetMessageId) { + this.wrapped.SetMessageId(aMessageId); + } + + this._result.messageIds.push(aMessageId); + }, + OnStopCopy(aStatus) { + if (this.wrapped && this.wrapped.OnStopCopy) { + this.wrapped.OnStopCopy(aStatus); + } + + if (aStatus == Cr.NS_OK) { + this._resolve(this._result); + } else { + this._reject(aStatus); + } + }, + get promise() { + return this._promise; + }, +}; + +/** + * Stream listener that can wrap another listener and trigger a callback. + * + * @param {nsIStreamListener} [aWrapped] - The nsIStreamListener to pass all + * notifications through to. This gets called prior to the callback + * (or async resumption). + */ +PromiseTestUtils.PromiseStreamListener = function (aWrapped) { + this.wrapped = aWrapped; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); + this._data = null; + this._stream = null; +}; + +PromiseTestUtils.PromiseStreamListener.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIStreamListener"]), + + onStartRequest(aRequest) { + if (this.wrapped && this.wrapped.onStartRequest) { + this.wrapped.onStartRequest(aRequest); + } + this._data = ""; + this._stream = null; + }, + + onStopRequest(aRequest, aStatusCode) { + if (this.wrapped && this.wrapped.onStopRequest) { + this.wrapped.onStopRequest(aRequest, aStatusCode); + } + if (aStatusCode == Cr.NS_OK) { + this._resolve(this._data); + } else { + this._reject(aStatusCode); + } + }, + + onDataAvailable(aRequest, aInputStream, aOff, aCount) { + if (this.wrapped && this.wrapped.onDataAvailable) { + this.wrapped.onDataAvailable(aRequest, aInputStream, aOff, aCount); + } + if (!this._stream) { + this._stream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance( + Ci.nsIScriptableInputStream + ); + this._stream.init(aInputStream); + } + this._data += this._stream.read(aCount); + }, + + get promise() { + return this._promise; + }, +}; + +/** + * Folder listener to resolve a promise when a certain folder event occurs. + * + * @param {nsIMsgFolder} folder - nsIMsgFolder to listen to + * @param {string} event - Event name to listen for. Example event is + * "DeleteOrMoveMsgCompleted". + * @returns {Promise} Promise that resolves when the event occurs. + */ +PromiseTestUtils.promiseFolderEvent = function (folder, event) { + return new Promise((resolve, reject) => { + let folderListener = { + QueryInterface: ChromeUtils.generateQI(["nsIFolderListener"]), + onFolderEvent(aEventFolder, aEvent) { + if (folder === aEventFolder && event == aEvent) { + MailServices.mailSession.RemoveFolderListener(folderListener); + resolve(); + } + }, + }; + MailServices.mailSession.AddFolderListener( + folderListener, + Ci.nsIFolderListener.event + ); + }); +}; + +/** + * Folder listener to resolve a promise when a certain folder event occurs. + * + * @param {nsIMsgFolder} folder - nsIMsgFolder to listen to. + * @param {string} listenerMethod - string listener method to listen for. + * Example listener method is "msgsClassified". + * @returns {Promise} Promise that resolves when the event occurs. + */ +PromiseTestUtils.promiseFolderNotification = function (folder, listenerMethod) { + return new Promise((resolve, reject) => { + let mfnListener = {}; + mfnListener[listenerMethod] = function () { + let args = Array.from(arguments); + let flag = true; + for (let arg of args) { + if (folder && arg instanceof Ci.nsIMsgFolder) { + if (arg == folder) { + flag = true; + break; + } else { + return; + } + } + } + + if (flag) { + MailServices.mfn.removeListener(mfnListener); + resolve(args); + } + }; + MailServices.mfn.addListener( + mfnListener, + Ci.nsIMsgFolderNotificationService[listenerMethod] + ); + }); +}; + +/** + * Folder listener to resolve a promise when a folder with a certain + * name is added. + * + * @param {string} folderName - folder name to listen for + * @returns {Promise} Promise that resolves with the new folder + * when the folder add completes. + */ +PromiseTestUtils.promiseFolderAdded = function (folderName) { + return new Promise((resolve, reject) => { + var listener = { + folderAdded: aFolder => { + if (aFolder.name == folderName) { + MailServices.mfn.removeListener(listener); + resolve(aFolder); + } + }, + }; + MailServices.mfn.addListener( + listener, + Ci.nsIMsgFolderNotificationService.folderAdded + ); + }); +}; + +/** + * Timer to resolve a promise after a delay + * + * @param {integer} aDelay - Delay in milliseconds + * @returns {Promise} Promise that resolves after the delay. + */ +PromiseTestUtils.promiseDelay = function (aDelay) { + return new Promise((resolve, reject) => { + let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + timer.initWithCallback(resolve, aDelay, Ci.nsITimer.TYPE_ONE_SHOT); + }); +}; + +/** + * Search listener to resolve a promise when a search completes + * + * @param {nsIMsgSearchSession} aSearchSession - The nsIMsgSearchSession to search + * @param {nsIMsgSearchNotify} aWrapped - The nsIMsgSearchNotify to pass all + * notifications through to. This gets called prior to the callback + * (or async resumption). + */ +PromiseTestUtils.PromiseSearchNotify = function (aSearchSession, aWrapped) { + this._searchSession = aSearchSession; + this._searchSession.registerListener(this); + this.wrapped = aWrapped; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); +}; + +PromiseTestUtils.PromiseSearchNotify.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIMsgSearchNotify"]), + onSearchHit(aHeader, aFolder) { + if (this.wrapped && this.wrapped.onSearchHit) { + this.wrapped.onSearchHit(aHeader, aFolder); + } + }, + onSearchDone(aResult) { + this._searchSession.unregisterListener(this); + if (this.wrapped && this.wrapped.onSearchDone) { + this.wrapped.onSearchDone(aResult); + } + if (aResult == Cr.NS_OK) { + this._resolve(); + } else { + this._reject(aResult); + } + }, + onNewSearch() { + if (this.wrapped && this.wrapped.onNewSearch) { + this.wrapped.onNewSearch(); + } + }, + get promise() { + return this._promise; + }, +}; diff --git a/comm/mailnews/test/resources/abSetup.js b/comm/mailnews/test/resources/abSetup.js new file mode 100644 index 0000000000..65e5e1bf82 --- /dev/null +++ b/comm/mailnews/test/resources/abSetup.js @@ -0,0 +1,80 @@ +/* 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/. */ + +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * Sets up the directory service provider to return the app dir as the profile + * directory for the address book to use for locating its files during the + * tests. + * + * Note there are further configuration setup items below this. + */ + +/** + * General Configuration Data that applies to the address book. + */ + +// Personal Address Book configuration items. +var kPABData = { + URI: "jsaddrbook://abook.sqlite", + fileName: "abook.sqlite", + dirName: "Personal Address Book", + dirType: 101, + dirPrefID: "ldap_2.servers.pab", + readOnly: false, + position: 1, +}; + +// Collected Address Book configuration items. +var kCABData = { + URI: "jsaddrbook://history.sqlite", + fileName: "history.sqlite", + dirName: "Collected Addresses", + dirType: 101, + dirPrefID: "ldap_2.servers.history", + readOnly: false, + position: 2, +}; + +// This currently applies to all address books of local type. +var kNormalPropertiesURI = + "chrome://messenger/content/addressbook/abAddressBookNameDialog.xhtml"; + +/** + * Installs a pre-prepared address book file into the profile directory. + * This version is for JS/SQLite address books, if you create a new type, + * replace this function to test them. + * + * @param {string} source - Path to the source data, without extension + * @param {string} dest - Final file name in the profile, with extension + */ +function loadABFile(source, dest) { + let sourceFile = do_get_file(`${source}.sql`); + let destFile = do_get_profile(); + destFile.append(dest); + + info(`Creating ${destFile.path} from ${sourceFile.path}`); + + let fstream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance( + Ci.nsIFileInputStream + ); + let cstream = Cc["@mozilla.org/intl/converter-input-stream;1"].createInstance( + Ci.nsIConverterInputStream + ); + fstream.init(sourceFile, -1, 0, 0); + cstream.init(fstream, "UTF-8", 0, 0); + + let data = ""; + let read = 0; + do { + let str = {}; + read = cstream.readString(0xffffffff, str); + data += str.value; + } while (read != 0); + cstream.close(); + + let conn = Services.storage.openDatabase(destFile); + conn.executeSimpleSQL(data); + conn.close(); +} diff --git a/comm/mailnews/test/resources/alertTestUtils.js b/comm/mailnews/test/resources/alertTestUtils.js new file mode 100644 index 0000000000..2b757480e1 --- /dev/null +++ b/comm/mailnews/test/resources/alertTestUtils.js @@ -0,0 +1,487 @@ +/* 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/. */ + +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * This file provides support for writing mailnews tests that require hooking + * into the alerts system. Normally these tests would require a UI and fail in + * debug mode, but with this method you can hook into the alerts system and + * avoid the UI. + * + * This file registers prompts for nsIWindowWatcher::getNewPrompter and also + * registers a nsIPromptService service. nsIWindowWatcher::getNewAuthPrompter + * is also implemented but returns the nsILoginManagerPrompter as this would + * be expected when running mailnews. + * + * To register the system: + * + * function run_test() { + * registerAlertTestUtils(); + * // ... + * } + * + * You can then hook into the alerts just by defining a function of the same + * name as the interface function: + * + * function alert(aDialogTitle, aText) { + * // do my check + * } + * + * Interface functions that do not have equivalent functions defined and get + * called will be treated as unexpected, and therefore they will call + * do_throw(). + */ +/* globals alert, confirm, prompt */ + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); +var { MockRegistrar } = ChromeUtils.importESModule( + "resource://testing-common/MockRegistrar.sys.mjs" +); + +var LoginInfo = Components.Constructor( + "@mozilla.org/login-manager/loginInfo;1", + "nsILoginInfo", + "init" +); + +// Wrapper to the nsIPrompt interface. +// This allows the send code to attempt to display errors to the user without +// failing. +var alertUtilsPrompts = { + alert(aDialogTitle, aText) { + if (typeof alert == "function") { + alert(aDialogTitle, aText); + return; + } + + do_throw("alert unexpectedly called: " + aText + "\n"); + }, + + alertCheck(aDialogTitle, aText, aCheckMsg, aCheckState) { + if (typeof alertCheck == "function") { + // eslint-disable-next-line no-undef + alertCheck(aDialogTitle, aText, aCheckMsg, aCheckState); + return; + } + + do_throw("alertCheck unexpectedly called: " + aText + "\n"); + }, + + confirm(aDialogTitle, aText) { + if (typeof confirm == "function") { + return confirm(aDialogTitle, aText); + } + + do_throw("confirm unexpectedly called: " + aText + "\n"); + return false; + }, + + confirmCheck(aDialogTitle, aText, aCheckMsg, aCheckState) { + if (typeof confirmCheck == "function") { + // eslint-disable-next-line no-undef + return confirmCheck(aDialogTitle, aText, aCheckMsg, aCheckState); + } + + do_throw("confirmCheck unexpectedly called: " + aText + "\n"); + return false; + }, + + confirmEx( + aDialogTitle, + aText, + aButtonFlags, + aButton0Title, + aButton1Title, + aButton2Title, + aCheckMsg, + aCheckState + ) { + if (typeof confirmEx == "function") { + // eslint-disable-next-line no-undef + return confirmEx( + aDialogTitle, + aText, + aButtonFlags, + aButton0Title, + aButton1Title, + aButton2Title, + aCheckMsg, + aCheckState + ); + } + + do_throw("confirmEx unexpectedly called: " + aText + "\n"); + return 0; + }, + + prompt(aDialogTitle, aText, aValue, aCheckMsg, aCheckState) { + if (typeof prompt == "function") { + return prompt(aDialogTitle, aText, aValue, aCheckMsg, aCheckState); + } + + do_throw("prompt unexpectedly called: " + aText + "\n"); + return false; + }, + + promptUsernameAndPassword( + aDialogTitle, + aText, + aUsername, + aPassword, + aCheckMsg, + aCheckState + ) { + if (typeof promptUsernameAndPassword == "function") { + // eslint-disable-next-line no-undef + return promptUsernameAndPassword( + aDialogTitle, + aText, + aUsername, + aPassword, + aCheckMsg, + aCheckState + ); + } + + do_throw("promptUsernameAndPassword unexpectedly called: " + aText + "\n"); + return false; + }, + + promptPassword(aDialogTitle, aText, aPassword, aCheckMsg, aCheckState) { + if (typeof promptPassword == "function") { + // eslint-disable-next-line no-undef + return promptPassword( + aDialogTitle, + aText, + aPassword, + aCheckMsg, + aCheckState + ); + } + + do_throw("promptPassword unexpectedly called: " + aText + "\n"); + return false; + }, + + select(aDialogTitle, aText, aCount, aSelectList, aOutSelection) { + if (typeof select == "function") { + // eslint-disable-next-line no-undef + return select(aDialogTitle, aText, aCount, aSelectList, aOutSelection); + } + + do_throw("select unexpectedly called: " + aText + "\n"); + return false; + }, + + QueryInterface: ChromeUtils.generateQI(["nsIPrompt"]), +}; + +var alertUtilsPromptService = { + alert(aParent, aDialogTitle, aText) { + if (typeof alertPS == "function") { + // eslint-disable-next-line no-undef + alertPS(aParent, aDialogTitle, aText); + return; + } + + do_throw("alertPS unexpectedly called: " + aText + "\n"); + }, + + alertCheck(aParent, aDialogTitle, aText, aCheckMsg, aCheckState) { + if (typeof alertCheckPS == "function") { + // eslint-disable-next-line no-undef + alertCheckPS(aParent, aDialogTitle, aText, aCheckMsg, aCheckState); + return; + } + + do_throw("alertCheckPS unexpectedly called: " + aText + "\n"); + }, + + confirm(aParent, aDialogTitle, aText) { + if (typeof confirmPS == "function") { + // eslint-disable-next-line no-undef + return confirmPS(aParent, aDialogTitle, aText); + } + + do_throw("confirmPS unexpectedly called: " + aText + "\n"); + return false; + }, + + confirmCheck(aParent, aDialogTitle, aText, aCheckMsg, aCheckState) { + if (typeof confirmCheckPS == "function") { + // eslint-disable-next-line no-undef + return confirmCheckPS( + aParent, + aDialogTitle, + aText, + aCheckMsg, + aCheckState + ); + } + + do_throw("confirmCheckPS unexpectedly called: " + aText + "\n"); + return false; + }, + + confirmEx( + aParent, + aDialogTitle, + aText, + aButtonFlags, + aButton0Title, + aButton1Title, + aButton2Title, + aCheckMsg, + aCheckState + ) { + if (typeof confirmExPS == "function") { + // eslint-disable-next-line no-undef + return confirmExPS( + aParent, + aDialogTitle, + aText, + aButtonFlags, + aButton0Title, + aButton1Title, + aButton2Title, + aCheckMsg, + aCheckState + ); + } + + do_throw("confirmExPS unexpectedly called: " + aText + "\n"); + return 0; + }, + + prompt(aParent, aDialogTitle, aText, aValue) { + if (typeof promptPS == "function") { + // eslint-disable-next-line no-undef + return promptPS(aParent, aDialogTitle, aText, aValue); + } + + do_throw("promptPS unexpectedly called: " + aText + "\n"); + return false; + }, + + promptUsernameAndPassword( + aParent, + aDialogTitle, + aText, + aUsername, + aPassword + ) { + if (typeof promptUsernameAndPasswordPS == "function") { + // eslint-disable-next-line no-undef + return promptUsernameAndPasswordPS( + aParent, + aDialogTitle, + aText, + aUsername, + aPassword + ); + } + + do_throw( + "promptUsernameAndPasswordPS unexpectedly called: " + aText + "\n" + ); + return false; + }, + + promptPassword(aParent, aDialogTitle, aText, aPassword) { + if (typeof promptPasswordPS == "function") { + // eslint-disable-next-line no-undef + return promptPasswordPS(aParent, aDialogTitle, aText, aPassword); + } + + do_throw("promptPasswordPS unexpectedly called: " + aText + "\n"); + return false; + }, + + select(aParent, aDialogTitle, aText, aCount, aSelectList, aOutSelection) { + if (typeof selectPS == "function") { + // eslint-disable-next-line no-undef + return selectPS( + aParent, + aDialogTitle, + aText, + aCount, + aSelectList, + aOutSelection + ); + } + + do_throw("selectPS unexpectedly called: " + aText + "\n"); + return false; + }, + + createInstance(iid) { + return this.QueryInterface(iid); + }, + + QueryInterface: ChromeUtils.generateQI([ + "nsIPromptService", + "nsIPromptService2", + ]), +}; + +var alertUtilsWindowWatcher = { + getNewPrompter(aParent) { + return alertUtilsPrompts; + }, + + getNewAuthPrompter(aParent) { + return Cc["@mozilla.org/login-manager/authprompter;1"].getService( + Ci.nsIAuthPrompt + ); + }, + + QueryInterface: ChromeUtils.generateQI(["nsIWindowWatcher"]), +}; + +// Special prompt that ensures we get prompted for logins. Calls +// promptPasswordPS/promptUsernameAndPasswordPS directly, rather than through +// the prompt service, because the function signature changed and no longer +// allows a "save password" check box. +let alertUtilsMsgAuthPrompt = { + QueryInterface: ChromeUtils.generateQI(["nsIAuthPrompt"]), + + _getFormattedOrigin(aURI) { + let uri; + if (aURI instanceof Ci.nsIURI) { + uri = aURI; + } else { + uri = Services.io.newURI(aURI); + } + + return uri.scheme + "://" + uri.displayHostPort; + }, + + _getRealmInfo(aRealmString) { + var httpRealm = /^.+ \(.+\)$/; + if (httpRealm.test(aRealmString)) { + return [null, null, null]; + } + + var uri = Services.io.newURI(aRealmString); + var pathname = ""; + + if (uri.pathQueryRef != "/") { + pathname = uri.pathQueryRef; + } + + var formattedOrigin = this._getFormattedOrigin(uri); + + return [formattedOrigin, formattedOrigin + pathname, uri.username]; + }, + + promptUsernameAndPassword( + aDialogTitle, + aText, + aPasswordRealm, + aSavePassword, + aUsername, + aPassword + ) { + var checkBox = { value: false }; + var checkBoxLabel = null; + var [origin, realm] = this._getRealmInfo(aPasswordRealm); + + if (typeof promptUsernameAndPasswordPS != "function") { + throw new Error( + "promptUsernameAndPasswordPS unexpectedly called: " + aText + "\n" + ); + } + + // eslint-disable-next-line no-undef + var ok = promptUsernameAndPasswordPS( + this._chromeWindow, + aDialogTitle, + aText, + aUsername, + aPassword, + checkBoxLabel, + checkBox + ); + + if (!ok || !checkBox.value || !origin) { + return ok; + } + + if (!aPassword.value) { + return ok; + } + + let newLogin = new LoginInfo( + origin, + null, + realm, + aUsername.value, + aPassword.value + ); + Services.logins.addLogin(newLogin); + + return ok; + }, + + promptPassword( + aDialogTitle, + aText, + aPasswordRealm, + aSavePassword, + aPassword + ) { + var checkBox = { value: false }; + var checkBoxLabel = null; + var [origin, realm, username] = this._getRealmInfo(aPasswordRealm); + + username = decodeURIComponent(username); + + if (typeof promptPasswordPS != "function") { + throw new Error("promptPasswordPS unexpectedly called: " + aText + "\n"); + } + + // eslint-disable-next-line no-undef + var ok = promptPasswordPS( + this._chromeWindow, + aDialogTitle, + aText, + aPassword, + checkBoxLabel, + checkBox + ); + + if (ok && checkBox.value && origin && aPassword.value) { + let newLogin = new LoginInfo( + origin, + null, + realm, + username, + aPassword.value + ); + + Services.logins.addLogin(newLogin); + } + + return ok; + }, +}; + +function registerAlertTestUtils() { + MockRegistrar.register( + "@mozilla.org/embedcomp/window-watcher;1", + alertUtilsWindowWatcher + ); + MockRegistrar.register( + "@mozilla.org/messenger/msgAuthPrompt;1", + alertUtilsMsgAuthPrompt + ); + MockRegistrar.register("@mozilla.org/prompter;1", alertUtilsPromptService); + Services.prompt = alertUtilsPromptService; +} + +var gDummyMsgWindow = Cc["@mozilla.org/messenger/msgwindow;1"].createInstance( + Ci.nsIMsgWindow +); diff --git a/comm/mailnews/test/resources/filterTestUtils.js b/comm/mailnews/test/resources/filterTestUtils.js new file mode 100644 index 0000000000..c34d1147c0 --- /dev/null +++ b/comm/mailnews/test/resources/filterTestUtils.js @@ -0,0 +1,89 @@ +/* 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/. */ + +// Utility functions for testing interactions with filters. + +var contains = Ci.nsMsgSearchOp.Contains; +// This maps strings to a filter attribute (excluding the parameter) +var ATTRIB_MAP = { + // Template : [attrib, op, field of value, otherHeader] + subject: [Ci.nsMsgSearchAttrib.Subject, contains, "str", null], + from: [Ci.nsMsgSearchAttrib.Sender, contains, "str", null], + date: [Ci.nsMsgSearchAttrib.Date, Ci.nsMsgSearchOp.Is, "date", null], + size: [Ci.nsMsgSearchAttrib.Size, Ci.nsMsgSearchOp.Is, "size", null], + "message-id": [ + Ci.nsMsgSearchAttrib.OtherHeader + 1, + contains, + "str", + "Message-ID", + ], + "user-agent": [ + Ci.nsMsgSearchAttrib.OtherHeader + 2, + contains, + "str", + "User-Agent", + ], +}; +// And this maps strings to filter actions +var ACTION_MAP = { + // Template : [action, auxiliary attribute field, auxiliary value] + priority: [Ci.nsMsgFilterAction.ChangePriority, "priority", 6], + delete: [Ci.nsMsgFilterAction.Delete], + read: [Ci.nsMsgFilterAction.MarkRead], + unread: [Ci.nsMsgFilterAction.MarkUnread], + kill: [Ci.nsMsgFilterAction.KillThread], + watch: [Ci.nsMsgFilterAction.WatchThread], + flag: [Ci.nsMsgFilterAction.MarkFlagged], + stop: [Ci.nsMsgFilterAction.StopExecution], + tag: [Ci.nsMsgFilterAction.AddTag, "strValue", "tag"], +}; + +/** + * Creates a filter and appends it to the nsIMsgFilterList. + * + * @param {nsIMsgFilter} list - An nsIMsgFilter to which the new filter will be appended. + * @param {string} trigger - A key of ATTRIB_MAP that represents the filter trigger. + * @param {string} value - The value of the filter trigger. + * @param {nsMsgFilterAction} action - A key of ACTION_MAP that represents the action to be taken. + */ +function createFilter(list, trigger, value, action) { + var filter = list.createFilter(trigger + action + "Test"); + filter.filterType = Ci.nsMsgFilterType.NewsRule; + + var searchTerm = filter.createTerm(); + searchTerm.matchAll = false; + if (trigger in ATTRIB_MAP) { + let information = ATTRIB_MAP[trigger]; + searchTerm.attrib = information[0]; + if (information[3] != null) { + searchTerm.arbitraryHeader = information[3]; + } + searchTerm.op = information[1]; + var oldValue = searchTerm.value; + oldValue.attrib = information[0]; + oldValue[information[2]] = value; + searchTerm.value = oldValue; + } else { + throw new Error("Unknown trigger " + trigger); + } + searchTerm.booleanAnd = true; + filter.appendTerm(searchTerm); + + var filterAction = filter.createAction(); + if (action in ACTION_MAP) { + let information = ACTION_MAP[action]; + filterAction.type = information[0]; + if (1 in information) { + filterAction[information[1]] = information[2]; + } + } else { + throw new Error("Unknown action " + action); + } + filter.appendAction(filterAction); + + filter.enabled = true; + + // Add to the end + list.insertFilterAt(list.filterCount, filter); +} diff --git a/comm/mailnews/test/resources/folderEventLogHelper.js b/comm/mailnews/test/resources/folderEventLogHelper.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/comm/mailnews/test/resources/logHelper.js b/comm/mailnews/test/resources/logHelper.js new file mode 100644 index 0000000000..88a9616904 --- /dev/null +++ b/comm/mailnews/test/resources/logHelper.js @@ -0,0 +1,567 @@ +/* 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/. */ + +/* + * Makes everything awesome if you are Andrew. Some day it will make everything + * awesome if you are not awesome too. + * + * Right now the most meaningful thing to know is that if XPCOM failures happen + * (and get reported to the error console), this will induce a unit test + * failure. You should think this is awesome no matter whether you are Andrew + * or not. + */ + +// eslint-disable-next-line mozilla/reject-importGlobalProperties +Cu.importGlobalProperties(["Element", "Node"]); + +var _mailnewsTestLogger; +var _xpcshellLogger; +var _testLoggerContexts = []; +var _testLoggerContextId = 0; +var _testLoggerActiveContext; + +var _logHelperInterestedListeners = false; + +/** + * Let test code extend the list of allowed XPCOM errors. + */ +var logHelperAllowedErrors = ["NS_ERROR_FAILURE"]; +var logHelperAllowedWarnings = [/Quirks Mode/]; + +/** + * Let other test helping code decide whether to register for potentially + * expensive notifications based on whether anyone can even hear those + * results. + */ +function logHelperHasInterestedListeners() { + return _logHelperInterestedListeners; +} + +/** + * Tunnel nsIScriptErrors that show up on the error console to ConsoleInstance. + * We could send everything but I think only script errors are likely of much + * concern. Also, this nicely avoids infinite recursions no matter what you do + * since what we publish is not going to end up as an nsIScriptError. + * + * This is based on my (asuth') exmmad extension. + */ +var _errorConsoleTunnel = { + initialize() { + Services.console.registerListener(this); + + // we need to unregister our listener at shutdown if we don't want explosions + Services.obs.addObserver(this, "quit-application"); + }, + + shutdown() { + Services.console.unregisterListener(this); + Services.obs.removeObserver(this, "quit-application"); + }, + + observe(aMessage, aTopic, aData) { + if (aTopic == "quit-application") { + this.shutdown(); + return; + } + + try { + if ( + aMessage instanceof Ci.nsIScriptError && + !aMessage.errorMessage.includes("Error console says") + ) { + // Unfortunately changes to mozilla-central are throwing lots + // of console errors during testing, so disable (we hope temporarily) + // failing on XPCOM console errors (see bug 1014350). + // An XPCOM error aMessage looks like this: + // [JavaScript Error: "uncaught exception: 2147500037"] + // Capture the number, and allow known XPCOM results. + let matches = /JavaScript Error: "(\w+)/.exec(aMessage); + let XPCOMresult = null; + if (matches) { + for (let result in Cr) { + if (matches[1] == Cr[result]) { + XPCOMresult = result; + break; + } + } + let message = XPCOMresult || aMessage; + if (logHelperAllowedErrors.some(e => e == matches[1])) { + if (XPCOMresult) { + info("Ignoring XPCOM error: " + message); + } + return; + } + info("Found XPCOM error: " + message); + } + // Ignore warnings that match a white-listed pattern. + if ( + /JavaScript Warning:/.test(aMessage) && + logHelperAllowedWarnings.some(w => w.test(aMessage)) + ) { + return; + } + dump(`Error console says: ${aMessage}`); + } + } catch (ex) { + // This is to avoid pathological error loops. we definitely do not + // want to propagate an error here. + } + }, +}; + +// This defaults to undefined and is for use by test-folder-display-helpers +// so that it can pre-initialize the value so that when we are evaluated in +// its subscript loader we see a value of 'true'. +var _do_not_wrap_xpcshell; + +/** + * Initialize logging. The idea is to: + * + * - Always create a dump appender on 'test'. + * - Check if there's a desire to use a logsploder style network connection + * based on the presence of an appropriate file in 'tmp'. This should be + * harmless in cases where there is not such a file. + * + * We will wrap the interesting xpcshell functions if we believe there is an + * endpoint that cares about these things (such as logsploder). + */ +function _init_log_helper() { + // - dump on test + _mailnewsTestLogger = console.createInstance({ + prefix: "test.test", + }); + + // - silent category for xpcshell stuff that already gets dump()ed + _xpcshellLogger = console.createInstance({ + prefix: "xpcshell", + }); + + // Create a console listener reporting thinger in all cases. Since XPCOM + // failures will show up via the error console, this allows our test to fail + // in more situations where we might otherwise silently be cool with bad + // things happening. + _errorConsoleTunnel.initialize(); + + if (_logHelperInterestedListeners) { + if (!_do_not_wrap_xpcshell) { + _wrap_xpcshell_functions(); + } + + // Send a message telling the listeners about the test file being run. + _xpcshellLogger.info({ + _jsonMe: true, + _isContext: true, + _specialContext: "lifecycle", + _id: "start", + testFile: _TEST_FILE, + }); + } +} +_init_log_helper(); + +/** + * Mark the start of a test. This creates nice console output as well as + * setting up logging contexts so that use of other helpers in here + * get associated with the context. + * + * This will likely only be used by the test driver framework, such as + * asyncTestUtils.js. However, |mark_sub_test_start| is for user test code. + */ +function mark_test_start(aName, aParameter, aDepth) { + if (aDepth == null) { + aDepth = 0; + } + + // clear out any existing contexts + mark_test_end(aDepth); + + let term = aDepth == 0 ? "test" : "subtest"; + _testLoggerActiveContext = { + type: term, + name: aName, + parameter: aParameter, + _id: ++_testLoggerContextId, + }; + if (_testLoggerContexts.length) { + _testLoggerActiveContext._contextDepth = _testLoggerContexts.length; + _testLoggerActiveContext._contextParentId = + _testLoggerContexts[_testLoggerContexts.length - 1]._id; + } + _testLoggerContexts.push(_testLoggerActiveContext); + + _mailnewsTestLogger.info( + _testLoggerActiveContext._id, + "Starting " + term + ": " + aName + (aParameter ? ", " + aParameter : "") + ); +} + +/** + * Mark the end of a test started by |mark_test_start|. + */ +function mark_test_end(aPopTo) { + if (aPopTo === undefined) { + aPopTo = 0; + } + // clear out any existing contexts + while (_testLoggerContexts.length > aPopTo) { + let context = _testLoggerContexts.pop(); + _mailnewsTestLogger.info( + context._id, + "Finished " + + context.type + + ": " + + context.name + + (context.parameter ? ", " + context.parameter : "") + ); + } +} + +/** + * For user test code and test support code to mark sub-regions of tests. + * + * @param {string} aName The name of the (sub) test. + * @param {string} [aParameter=null] The parameter if the test is being parameterized. + * @param {boolean} [aNest=false] Should this nest inside other sub-tests? + * If you omit orpass false, we will close out any existing sub-tests. + * If you pass true, we nest inside the previous test/sub-test and rely on + * you to call |mark_sub_test_end|. + * Sub tests can lost no longer than their parent. + * You should strongly consider using the aNest parameter if you are test + * support code. + */ +function mark_sub_test_start(aName, aParameter, aNest) { + let depth = aNest ? _testLoggerContexts.length : 1; + mark_test_start(aName, aParameter, depth); +} + +/** + * Mark the end of a sub-test. Because sub-tests can't outlive their parents, + * there is no ambiguity about what sub-test we are closing out. + */ +function mark_sub_test_end() { + if (_testLoggerContexts.length <= 1) { + return; + } + mark_test_end(_testLoggerContexts.length - 1); +} + +/** + * Express that all tests were run to completion. This helps the listener + * distinguish between successful termination and abort-style termination where + * the process just keeled over and on one told us. + * + * This also tells us to clean up. + */ +function mark_all_tests_run() { + // make sure all tests get closed out + mark_test_end(); + + _xpcshellLogger.info("All finished"); +} + +function _explode_flags(aFlagWord, aFlagDefs) { + let flagList = []; + + for (let flagName in aFlagDefs) { + let flagVal = aFlagDefs[flagName]; + if (flagVal & aFlagWord) { + flagList.push(flagName); + } + } + + return flagList; +} + +var _registered_json_normalizers = []; + +/** + * Copy natives or objects, deferring to _normalize_for_json for objects. + */ +function __value_copy(aObj, aDepthAllowed) { + if (aObj == null || typeof aObj != "object") { + return aObj; + } + return _normalize_for_json(aObj, aDepthAllowed, true); +} + +/** + * Simple object copier to limit accidentally JSON-ing a ridiculously complex + * object graph or getting tripped up by prototypes. + * + * @param {object} aObj - Input object. + * @param {integer} aDepthAllowed - How many times we are allowed to recursively + * call ourselves. + */ +function __simple_obj_copy(aObj, aDepthAllowed) { + let oot = {}; + let nextDepth = aDepthAllowed - 1; + for (let key in aObj) { + // avoid triggering getters + if (aObj.__lookupGetter__(key)) { + oot[key] = "*getter*"; + continue; + } + let value = aObj[key]; + + if (value == null) { + oot[key] = null; + } else if (typeof value != "object") { + oot[key] = value; + } else if (!aDepthAllowed) { + // steal control flow if no more depth is allowed + oot[key] = "truncated, string rep: " + value.toString(); + } else if (Array.isArray(value)) { + // array? (not directly counted, but we will terminate because the + // child copying occurs using nextDepth...) + oot[key] = value.map(v => __value_copy(v, nextDepth)); + } else { + // it's another object! woo! + oot[key] = _normalize_for_json(value, nextDepth, true); + } + } + + // let's take advantage of the object's native toString now + oot._stringRep = aObj.toString(); + + return oot; +} + +var _INTERESTING_MESSAGE_HEADER_PROPERTIES = { + "gloda-id": 0, + "gloda-dirty": 0, + junkscore: "", + junkscoreorigin: "", + msgOffset: 0, + offlineMsgSize: 0, +}; + +/** + * Given an object, attempt to normalize it into an interesting JSON + * representation. + * + * We transform generally interesting mail objects like: + * - nsIMsgFolder + * - nsIMsgDBHdr + */ +function _normalize_for_json(aObj, aDepthAllowed, aJsonMeNotNeeded) { + if (aDepthAllowed === undefined) { + aDepthAllowed = 2; + } + + // if it's a simple type just return it direct + if (typeof aObj != "object") { + return aObj; + } else if (aObj == null) { + return aObj; + } + + // recursively transform arrays outright + if (Array.isArray(aObj)) { + return aObj.map(v => __value_copy(v, aDepthAllowed - 1)); + } + + // === Mail Specific === + // (but common and few enough to not split out) + if (aObj instanceof Ci.nsIMsgFolder) { + return { + type: "folder", + name: aObj.prettyName, + uri: aObj.URI, + flags: _explode_flags(aObj.flags, Ci.nsMsgFolderFlags), + }; + } else if (aObj instanceof Ci.nsIMsgDBHdr) { + let properties = {}; + for (let name in _INTERESTING_MESSAGE_HEADER_PROPERTIES) { + let propType = _INTERESTING_MESSAGE_HEADER_PROPERTIES[name]; + if (propType === 0) { + properties[name] = + aObj.getStringProperty(name) != "" + ? aObj.getUint32Property(name) + : null; + } else { + properties[name] = aObj.getStringProperty(name); + } + } + return { + type: "msgHdr", + name: aObj.folder.URI + "#" + aObj.messageKey, + subject: aObj.mime2DecodedSubject, + from: aObj.mime2DecodedAuthor, + to: aObj.mime2DecodedRecipients, + messageKey: aObj.messageKey, + messageId: aObj.messageId, + flags: _explode_flags(aObj.flags, Ci.nsMsgMessageFlags), + interestingProperties: properties, + }; + } else if (Node.isInstance(aObj)) { + // === Generic === + // DOM nodes, including elements + let name = aObj.nodeName; + let objAttrs = {}; + + if (Element.isInstance(aObj)) { + name += "#" + aObj.getAttribute("id"); + } + + if ("attributes" in aObj) { + let nodeAttrs = aObj.attributes; + for (let iAttr = 0; iAttr < nodeAttrs.length; iAttr++) { + objAttrs[nodeAttrs[iAttr].name] = nodeAttrs[iAttr].value; + } + } + + let bounds = { left: null, top: null, width: null, height: null }; + if ("getBoundingClientRect" in aObj) { + bounds = aObj.getBoundingClientRect(); + } + + return { + type: "domNode", + name, + value: aObj.nodeValue, + namespace: aObj.namespaceURI, + boundingClientRect: bounds, + attrs: objAttrs, + }; + } else if (aObj instanceof Ci.nsIDOMWindow) { + let winId, title; + if (aObj.document && aObj.document.documentElement) { + title = aObj.document.title; + winId = + aObj.document.documentElement.getAttribute("windowtype") || + aObj.document.documentElement.getAttribute("id") || + "unnamed"; + } else { + winId = "n/a"; + title = "no document"; + } + return { + type: "domWindow", + id: winId, + title, + location: "" + aObj.location, + coords: { x: aObj.screenX, y: aObj.screenY }, + dims: { width: aObj.outerWidth, height: aObj.outerHeight }, + }; + } else if (aObj instanceof Error) { + // Although straight JS exceptions should serialize pretty well, we can + // improve things by making "stack" more friendly. + return { + type: "error", + message: aObj.message, + fileName: aObj.fileName, + lineNumber: aObj.lineNumber, + name: aObj.name, + stack: aObj.stack ? aObj.stack.split(/\n\r?/g) : null, + _stringRep: aObj.message, + }; + } else if (aObj instanceof Ci.nsIException) { + return { + type: "error", + message: "nsIException: " + aObj.name, + fileName: aObj.filename, // intentionally lower-case + lineNumber: aObj.lineNumber, + name: aObj.name, + result: aObj.result, + stack: null, + }; + } else if (aObj instanceof Ci.nsIStackFrame) { + return { + type: "stackFrame", + name: aObj.name, + fileName: aObj.filename, // intentionally lower-case + lineNumber: aObj.lineNumber, + }; + } else if (aObj instanceof Ci.nsIScriptError) { + return { + type: "stackFrame", + name: aObj.errorMessage, + category: aObj.category, + fileName: aObj.sourceName, + lineNumber: aObj.lineNumber, + }; + } + + for (let [checkType, handler] of _registered_json_normalizers) { + if (aObj instanceof checkType) { + return handler(aObj); + } + } + + // Do not fall into simple object walking if this is an XPCOM interface. + // We might run across getters and that leads to nothing good. + if (aObj instanceof Ci.nsISupports) { + return { + type: "XPCOM", + name: aObj.toString(), + }; + } + + let simple_obj = __simple_obj_copy(aObj, aDepthAllowed); + if (!aJsonMeNotNeeded) { + simple_obj._jsonMe = true; + } + return simple_obj; +} + +function register_json_normalizer(aType, aHandler) { + _registered_json_normalizers.push([aType, aHandler]); +} + +/* + * Wrap the xpcshell test functions that do interesting things. The idea is + * that we clobber these only if we're going to value-add; that decision + * gets made up top in the initialization function. + * + * Since eq/neq fall-through to do_throw in the explosion case, we don't handle + * that since the scoping means that we're going to see the resulting + * do_throw. + */ + +var _orig_do_throw; +var _orig_do_check_neq; +var _orig_do_check_eq; +// do_check_true is implemented in terms of do_check_eq +// do_check_false is implemented in terms of do_check_eq + +function _CheckAction(aSuccess, aLeft, aRight, aStack) { + this.type = "check"; + this.success = aSuccess; + this.left = _normalize_for_json(aLeft); + this.right = _normalize_for_json(aRight); + this.stack = _normalize_for_json(aStack); +} +_CheckAction.prototype = { + _jsonMe: true, + // we don't need a toString because we should not go out to the console +}; + +/** + * Representation of a failure from do_throw. + */ +function _Failure(aText, aStack) { + this.type = "failure"; + this.text = aText; + this.stack = _normalize_for_json(aStack); +} +_Failure.prototype = { + _jsonMe: true, +}; + +function _wrapped_do_throw(text, stack) { + if (!stack) { + stack = Components.stack.caller; + } + + // We need to use an info because otherwise explosion loggers can get angry + // and they may be indiscriminate about what they subscribe to. + _xpcshellLogger.info(_testLoggerActiveContext, new _Failure(text, stack)); + + return _orig_do_throw(text, stack); +} + +function _wrap_xpcshell_functions() { + _orig_do_throw = do_throw; + do_throw = _wrapped_do_throw; // eslint-disable-line no-global-assign +} diff --git a/comm/mailnews/test/resources/mailShutdown.js b/comm/mailnews/test/resources/mailShutdown.js new file mode 100644 index 0000000000..0a5a5aa092 --- /dev/null +++ b/comm/mailnews/test/resources/mailShutdown.js @@ -0,0 +1,51 @@ +/* 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/. */ + +/* Provides methods to make sure our test shuts down mailnews properly. */ + +var { MockRegistrar } = ChromeUtils.importESModule( + "resource://testing-common/MockRegistrar.sys.mjs" +); + +// Notifies everyone that the we're shutting down. This is needed to make sure +// that e.g. the account manager closes and cleans up correctly. It is semi-fake +// because we don't actually do any work to make sure the profile goes away, but +// it will mimic the behaviour in the app sufficiently. +// +// See also http://developer.mozilla.org/en/Observer_Notifications +function postShutdownNotifications() { + // first give everyone a heads up about us shutting down. if someone wants + // to cancel this, our test should fail. + var cancelQuit = Cc["@mozilla.org/supports-PRBool;1"].createInstance( + Ci.nsISupportsPRBool + ); + Services.obs.notifyObservers(cancelQuit, "quit-application-requested"); + if (cancelQuit.data) { + do_throw("Cannot shutdown: Someone cancelled the quit request!"); + } + + // post all notifications in the right order. none of these are cancellable + Services.startup.advanceShutdownPhase( + Services.startup.SHUTDOWN_PHASE_APPSHUTDOWNCONFIRMED + ); + Services.startup.advanceShutdownPhase( + Services.startup.SHUTDOWN_PHASE_APPSHUTDOWNNETTEARDOWN + ); + Services.startup.advanceShutdownPhase( + Services.startup.SHUTDOWN_PHASE_APPSHUTDOWNTEARDOWN + ); + Services.startup.advanceShutdownPhase( + Services.startup.SHUTDOWN_PHASE_APPSHUTDOWN + ); + + // finally, the xpcom-shutdown notification is handled by XPCOM itself. +} + +MockRegistrar.unregisterAll(); + +// First do a gc to let anything not being referenced be cleaned up. +gc(); + +// Now shut everything down. +postShutdownNotifications(); diff --git a/comm/mailnews/test/resources/msgFolderListenerSetup.js b/comm/mailnews/test/resources/msgFolderListenerSetup.js new file mode 100644 index 0000000000..72eaedb7a3 --- /dev/null +++ b/comm/mailnews/test/resources/msgFolderListenerSetup.js @@ -0,0 +1,429 @@ +/* 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/. */ + +// ChromeUtils.import should be used for this, but it breaks mozmill. +// Assume whatever test loaded this file already has mailTestUtils. +/* globals mailTestUtils */ + +var { MailServices } = ChromeUtils.import( + "resource:///modules/MailServices.jsm" +); + +var allTestedEvents = + MailServices.mfn.msgAdded | + MailServices.mfn.msgsClassified | + MailServices.mfn.msgsJunkStatusChanged | + MailServices.mfn.msgsDeleted | + MailServices.mfn.msgsMoveCopyCompleted | + MailServices.mfn.msgKeyChanged | + MailServices.mfn.msgUnincorporatedMoved | + MailServices.mfn.folderAdded | + MailServices.mfn.folderDeleted | + MailServices.mfn.folderMoveCopyCompleted | + MailServices.mfn.folderRenamed | + MailServices.mfn.folderCompactStart | + MailServices.mfn.folderCompactFinish | + MailServices.mfn.folderReindexTriggered; + +// Current test being executed +var gTest = 1; + +// Which events are expected +var gExpectedEvents = []; + +// The current status (what all has been done) +var gCurrStatus = 0; +var kStatus = { + notificationsDone: 0x1, + onStopCopyDone: 0x2, + functionCallDone: 0x4, + everythingDone: 0, +}; +kStatus.everythingDone = + kStatus.notificationsDone | kStatus.onStopCopyDone | kStatus.functionCallDone; + +// For copyFileMessage: this stores the header that was received +var gHdrsReceived = []; + +var gMsgHdrs = []; + +// Our listener, which captures events and verifies them as they are received. +var gMFListener = { + msgAdded(aMsg) { + verify([MailServices.mfn.msgAdded, aMsg]); + // We might not actually have a header in gHdrsReceived in the IMAP case, + // so use the aMsg we got instead + gMsgHdrs.push({ hdr: aMsg, ID: aMsg.messageId }); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } else if (gExpectedEvents[0][0] == MailServices.mfn.msgsClassified) { + // XXX this is a hack to deal with limitations of the classification logic + // and the new list. We want to issue a call to clear the list once all + // the messages have been added, which would be when the next expected + // event is msgsClassified. (The limitation is that if we don't do this, + // we can end up getting told about this message again later.) + aMsg.folder.clearNewMessages(); + } + }, + + msgsClassified(aMsgs, aJunkProcessed, aTraitProcessed) { + dump("classified id: " + aMsgs[0].messageId + "\n"); + verify([ + MailServices.mfn.msgsClassified, + aMsgs, + aJunkProcessed, + aTraitProcessed, + ]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + msgsJunkStatusChanged(messages) { + verify([MailServices.mfn.msgsJunkStatusChanged, messages]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + msgsDeleted(aMsgs) { + verify([MailServices.mfn.msgsDeleted, aMsgs]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + msgsMoveCopyCompleted(aMove, aSrcMsgs, aDestFolder, aDestMsgs) { + verify([ + MailServices.mfn.msgsMoveCopyCompleted, + aMove, + aSrcMsgs, + aDestFolder, + aDestMsgs, + ]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + msgKeyChanged(aOldKey, aNewMsgHdr) { + verify([MailServices.mfn.msgKeyChanged, aOldKey, aNewMsgHdr]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + msgUnincorporatedMoved(srcFolder, msg) { + verify([MailServices.mfn.msgUnincorporatedMoved, srcFolder, msg]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderAdded(aFolder) { + verify([MailServices.mfn.folderAdded, aFolder]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderDeleted(aFolder) { + verify([MailServices.mfn.folderDeleted, aFolder]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderMoveCopyCompleted(aMove, aSrcFolder, aDestFolder) { + verify([ + MailServices.mfn.folderMoveCopyCompleted, + aMove, + aSrcFolder, + aDestFolder, + ]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderRenamed(aOrigFolder, aNewFolder) { + verify([MailServices.mfn.folderRenamed, aOrigFolder, aNewFolder]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderCompactStart(folder) { + verify([MailServices.mfn.folderCompactStart, folder]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderCompactFinish(folder) { + verify([MailServices.mfn.folderCompactFinish, folder]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, + + folderReindexTriggered(folder) { + verify([MailServices.mfn.folderReindexTriggered, folder]); + if (gExpectedEvents.length == 0) { + gCurrStatus |= kStatus.notificationsDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + } + }, +}; + +// Copy listener, for proceeding after each operation. +var copyListener = { + // For copyFileMessage: this should be the folder the message is being stored to + mFolderStoredIn: null, + mMessageId: "", + OnStartCopy() {}, + OnProgress(aProgress, aProgressMax) {}, + SetMessageKey(aKey) { + gHdrsReceived.push(this.mFolderStoredIn.GetMessageHeader(aKey)); + }, + GetMessageId(aMessageId) { + aMessageId = { value: this.mMessageId }; + }, + OnStopCopy(aStatus) { + // Check: message successfully copied. + Assert.equal(aStatus, 0); + gCurrStatus |= kStatus.onStopCopyDone; + if (gCurrStatus == kStatus.everythingDone) { + resetStatusAndProceed(); + } + }, +}; + +function resetStatusAndProceed() { + gHdrsReceived.length = 0; + gCurrStatus = 0; + // Ugly hack: make sure we don't get stuck in a JS->C++->JS->C++... call stack + // This can happen with a bunch of synchronous functions grouped together, and + // can even cause tests to fail because they're still waiting for the listener + // to return + do_timeout(0, () => { + this.doTest(++gTest); + }); +} + +// Checks whether the array returned from a function has exactly these elements. +function hasExactlyElements(array, elements) { + // If an nsIArray (it could also be a single header or a folder) + if (elements instanceof Ci.nsIArray) { + var count = elements.length; + + // Check: array sizes should be equal. + Assert.equal(count, array.length); + + for (let i = 0; i < count; i++) { + // Check: query element, must be a header or folder and present in the array + var currElement; + try { + currElement = elements.queryElementAt(i, Ci.nsIMsgDBHdr); + } catch (e) {} + if (!currElement) { + try { + currElement = elements.queryElementAt(i, Ci.nsIMsgFolder); + } catch (e) {} + } + Assert.equal(typeof currElement, "object"); + Assert.notEqual( + mailTestUtils.non_strict_index_of(array, currElement), + -1 + ); + } + } else if (Array.isArray(elements)) { + Assert.equal(elements.length, array.length); + for (let el of elements) { + Assert.equal(typeof el, "object"); + Assert.equal( + el instanceof Ci.nsIMsgDBHdr || el instanceof Ci.nsIMsgFolder, + true + ); + Assert.notEqual(mailTestUtils.non_strict_index_of(array, el), -1); + } + } else if ( + elements instanceof Ci.nsIMsgDBHdr || + elements instanceof Ci.nsIMsgFolder + ) { + // If a single header or a folder + + // Check: there should be only one element in the array. + Assert.equal(array.length, 1); + + // Check: the element should be present + Assert.notEqual(mailTestUtils.non_strict_index_of(array, elements), -1); + } else { + // This shouldn't happen + do_throw("Unrecognized item returned from listener"); + } +} + +// Verifies an event +function verify(event) { + // Check: make sure we actually have an item to process + Assert.ok(gExpectedEvents.length >= 1); + var expected = gExpectedEvents.shift(); + + // Check: events match. + var eventType = expected[0]; + Assert.equal(event[0], eventType); + + dump("..... Verifying event type " + eventType + "\n"); + + switch (eventType) { + case MailServices.mfn.msgAdded: + // So for IMAP right now, we aren't able to get the actual nsIMsgDBHdr. + // Instead, we'll match up message ids as a (poor?) substitute. + if (expected[1].expectedMessageId) { + Assert.equal(expected[1].expectedMessageId, event[1].messageId); + break; + } + // If we do have a header, fall through to the case below + case MailServices.mfn.msgsDeleted: + case MailServices.mfn.folderDeleted: + // Check: headers match/folder matches. + hasExactlyElements(expected[1], event[1]); + break; + case MailServices.mfn.msgsClassified: + // In the IMAP case expected[1] is a list of mesage-id strings whereas in + // the local case (where we are copying from files), we actually have + // the headers. + if (typeof expected[1][0] == "string") { + // IMAP; message id strings + // The IMAP case has additional complexity in that the 'new message' + // list is not tailored to our needs and so may over-report about + // new messagse. So to deal with this we make sure the msgsClassified + // event is telling us about at least the N expected events and that + // the last N of these events match + if (event[1].length < expected[1].length) { + do_throw("Not enough reported classified messages."); + } + let ignoreCount = event[1].length - expected[1].length; + for (let i = 0; i < expected[1].length; i++) { + let eventHeader = event[1][i + ignoreCount]; + Assert.equal(expected[1][i], eventHeader.messageId); + } + } else { + // actual headers + hasExactlyElements(expected[1], event[1]); + } + // aJunkProcessed: was the message processed for junk? + Assert.equal(expected[2], event[2]); + // aTraitProcessed: was the message processed for traits? + Assert.equal(expected[3], event[3]); + break; + case MailServices.mfn.msgsJunkStatusChanged: + // Check: same messages? + hasExactlyElements(expected[1], event[1]); + break; + case MailServices.mfn.msgKeyChanged: + Assert.equal(expected[1].expectedMessageId, event[2].messageId); + break; + case MailServices.mfn.msgUnincorporatedMoved: + // Check: Same folder? + Assert.equal(expected[1].URI, event[1].URI); + // Check: message matches? + hasExactlyElements(expected[2], event[2]); + break; + case MailServices.mfn.msgsMoveCopyCompleted: + case MailServices.mfn.folderMoveCopyCompleted: + // Check: Move or copy as expected. + Assert.equal(expected[1], event[1]); + + // Check: headers match/folder matches. + hasExactlyElements(expected[2], event[2]); + + // Check: destination folder matches. + Assert.equal(expected[3].URI, event[3].URI); + + if (eventType == MailServices.mfn.folderMoveCopyCompleted) { + break; + } + + // Check: destination headers. We expect these for local and imap folders, + // but we will not have heard about the headers ahead of time, + // so the best we can do is make sure they match up. To this end, + // we check that the message-id header values match up. + for (let iMsg = 0; iMsg < event[2].length; iMsg++) { + let srcHdr = event[2][iMsg]; + let destHdr = event[4][iMsg]; + Assert.equal(srcHdr.messageId, destHdr.messageId); + } + break; + case MailServices.mfn.folderAdded: + // Check: parent folder matches + Assert.equal(expected[1].URI, event[1].parent.URI); + + // Check: folder name matches + Assert.equal(expected[2], event[1].prettyName); + Assert.equal(expected[2], event[1].name); + + // Not a check, but call the passed in callback with the new folder, + // used e.g. to store this folder somewhere. + if (expected[3]) { + expected[3](event[1]); + } + break; + case MailServices.mfn.folderRenamed: + // Check: source folder matches + hasExactlyElements(expected[1], event[1]); + + // Check: destination folder name matches + Assert.equal(expected[2], event[2].prettyName); + break; + case MailServices.mfn.folderCompactStart: + case MailServices.mfn.folderCompactFinish: + case MailServices.mfn.folderReindexTriggered: + // Check: same folder? + Assert.equal(expected[1].URI, event[1].URI); + break; + } +} diff --git a/comm/mailnews/test/resources/passwordStorage.js b/comm/mailnews/test/resources/passwordStorage.js new file mode 100644 index 0000000000..26db74c5a7 --- /dev/null +++ b/comm/mailnews/test/resources/passwordStorage.js @@ -0,0 +1,23 @@ +/* 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/. */ + +/* globals gDEPTH */ + +if (typeof gDEPTH == "undefined") { + do_throw("gDEPTH must be defined when using passwordStorage.js"); +} + +/** + * Use the given storage database as the current signon database. + * + * @returns {Promise} Promive for when the storage database is usable. + */ +function setupForPassword(storageName) { + let keyDB = do_get_file(gDEPTH + "mailnews/data/key4.db"); + keyDB.copyTo(do_get_profile(), "key4.db"); + + let signons = do_get_file(gDEPTH + "mailnews/data/" + storageName); + signons.copyTo(do_get_profile(), "logins.json"); + return Services.logins.initializationPromise; +} diff --git a/comm/mailnews/test/resources/searchTestUtils.js b/comm/mailnews/test/resources/searchTestUtils.js new file mode 100644 index 0000000000..df26824bca --- /dev/null +++ b/comm/mailnews/test/resources/searchTestUtils.js @@ -0,0 +1,134 @@ +/* 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/. */ + +// Contains various functions commonly used in testing mailnews search. + +/** + * TestSearch: Class to test number of search hits + * + * @param {nsIMsgFolder} aFolder - The folder to search + * @param {string|integer} aValue - value used for the search + * The interpretation of aValue depends on aAttrib. It + * defaults to string, but for certain attributes other + * types are used. + * WARNING: not all attributes have been tested. + * + * @param {nsMsgSearchAttrib} aAttrib - Attribute for the search (Ci.nsMsgSearchAttrib.Size, etc.) + * @param {nsMsgSearchOp} aOp - Operation for the search (Ci.nsMsgSearchOp.Contains, etc.) + * @param {integer} aHitCount - Expected number of search hits + * @param {Function} onDone - Function to call on completion of search + * @param {string} aCustomId - Id string for the custom action, if aAttrib is Custom + * @param {string} aArbitraryHeader - For OtherHeader case, header. + * @param {string|integer} aHdrProperty - For HdrProperty and Uint32HdrProperty case + * + */ +function TestSearch( + aFolder, + aValue, + aAttrib, + aOp, + aHitCount, + onDone, + aCustomId, + aArbitraryHeader, + aHdrProperty +) { + var searchListener = { + onSearchHit(dbHdr, folder) { + hitCount++; + }, + onSearchDone(status) { + print("Finished search does " + aHitCount + " equal " + hitCount + "?"); + searchSession = null; + Assert.equal(aHitCount, hitCount); + if (onDone) { + onDone(); + } + }, + onNewSearch() { + hitCount = 0; + }, + }; + + // define and initiate the search session + + var hitCount; + var searchSession = Cc[ + "@mozilla.org/messenger/searchSession;1" + ].createInstance(Ci.nsIMsgSearchSession); + searchSession.addScopeTerm(Ci.nsMsgSearchScope.offlineMail, aFolder); + var searchTerm = searchSession.createTerm(); + searchTerm.attrib = aAttrib; + + var value = searchTerm.value; + // This is tricky - value.attrib must be set before actual values + value.attrib = aAttrib; + if (aAttrib == Ci.nsMsgSearchAttrib.JunkPercent) { + value.junkPercent = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.Priority) { + value.priority = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.Date) { + value.date = aValue; + } else if ( + aAttrib == Ci.nsMsgSearchAttrib.MsgStatus || + aAttrib == Ci.nsMsgSearchAttrib.FolderFlag || + aAttrib == Ci.nsMsgSearchAttrib.Uint32HdrProperty + ) { + value.status = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.MessageKey) { + value.msgKey = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.Size) { + value.size = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.AgeInDays) { + value.age = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.JunkStatus) { + value.junkStatus = aValue; + } else if (aAttrib == Ci.nsMsgSearchAttrib.HasAttachmentStatus) { + value.status = Ci.nsMsgMessageFlags.Attachment; + } else { + value.str = aValue; + } + searchTerm.value = value; + searchTerm.op = aOp; + searchTerm.booleanAnd = false; + if (aAttrib == Ci.nsMsgSearchAttrib.Custom) { + searchTerm.customId = aCustomId; + } else if (aAttrib == Ci.nsMsgSearchAttrib.OtherHeader) { + searchTerm.arbitraryHeader = aArbitraryHeader; + } else if ( + aAttrib == Ci.nsMsgSearchAttrib.HdrProperty || + aAttrib == Ci.nsMsgSearchAttrib.Uint32HdrProperty + ) { + searchTerm.hdrProperty = aHdrProperty; + } + + searchSession.appendTerm(searchTerm); + searchSession.registerListener(searchListener); + searchSession.search(null); +} + +/* + * Test search validity table Available and Enabled settings + * + * @param aScope: search scope (Ci.nsMsgSearchScope.offlineMail, etc.) + * @param aOp: search operation (Ci.nsMsgSearchOp.Contains, etc.) + * @param aAttrib: search attribute (Ci.nsMsgSearchAttrib.Size, etc.) + * @param aValue: expected value (true/false) for Available and Enabled + */ +const gValidityManager = Cc[ + "@mozilla.org/mail/search/validityManager;1" +].getService(Ci.nsIMsgSearchValidityManager); + +function testValidityTable(aScope, aOp, aAttrib, aValue) { + var validityTable = gValidityManager.getTable(aScope); + var isAvailable = validityTable.getAvailable(aAttrib, aOp); + var isEnabled = validityTable.getEnabled(aAttrib, aOp); + if (aValue) { + Assert.ok(isAvailable); + Assert.ok(isEnabled); + } else { + Assert.ok(!isAvailable); + Assert.ok(!isEnabled); + } +} diff --git a/comm/mailnews/test/resources/smimeUtils.jsm b/comm/mailnews/test/resources/smimeUtils.jsm new file mode 100644 index 0000000000..db7cf2e5c9 --- /dev/null +++ b/comm/mailnews/test/resources/smimeUtils.jsm @@ -0,0 +1,71 @@ +/* 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/. */ + +/** + * This file provides some utilities for helping run S/MIME tests. + */ + +var EXPORTED_SYMBOLS = ["SmimeUtils"]; + +var { MockRegistrar } = ChromeUtils.importESModule( + "resource://testing-common/MockRegistrar.sys.mjs" +); + +const gCertDialogs = { + confirmDownloadCACert: (ctx, cert, trust) => { + dump("Requesting certificate download\n"); + trust.value = Ci.nsIX509CertDB.TRUSTED_EMAIL; + return true; + }, + setPKCS12FilePassword: (ctx, password) => { + throw new Error("Not implemented"); + }, + getPKCS12FilePassword: (ctx, password) => { + password.value = ""; + return true; + }, + viewCert: (ctx, cert) => { + throw new Error("Not implemented"); + }, + QueryInterface: ChromeUtils.generateQI(["nsICertificateDialogs"]), +}; + +var SmimeUtils = { + ensureNSS() { + // Ensure NSS is initialized. + Cc["@mozilla.org/psm;1"].getService(Ci.nsISupports); + + // Set up the internal key token so that subsequent code doesn't fail. If + // this isn't done, we'll fail to work if the NSS databases didn't already + // exist. + let keydb = Cc["@mozilla.org/security/pk11tokendb;1"].getService( + Ci.nsIPK11TokenDB + ); + try { + keydb.getInternalKeyToken().initPassword(""); + } catch (e) { + // In this scenario, the key token already had its password initialized. + // Therefore, we don't need to do anything (assuming its password is + // empty). + } + + MockRegistrar.register("@mozilla.org/nsCertificateDialogs;1", gCertDialogs); + }, + + loadPEMCertificate(file, certType, loadKey = false) { + dump("Loading certificate from " + file.path + "\n"); + let certDB = Cc["@mozilla.org/security/x509certdb;1"].getService( + Ci.nsIX509CertDB + ); + certDB.importCertsFromFile(file, certType); + }, + + loadCertificateAndKey(file, pw) { + dump("Loading key from " + file.path + "\n"); + let certDB = Cc["@mozilla.org/security/x509certdb;1"].getService( + Ci.nsIX509CertDB + ); + certDB.importPKCS12File(file, pw); + }, +}; -- cgit v1.2.3