imapflow 1.2.13 → 1.2.15

package/test/charsets-test.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const { resolveCharset } = require('../lib/charsets');
+
+// ============================================
+// Canonical name resolution
+// ============================================
+
+module.exports['Charsets: resolves canonical UTF-8'] = test => {
+    test.equal(resolveCharset('UTF-8'), 'UTF-8');
+    test.done();
+};
+
+module.exports['Charsets: resolves canonical ISO-8859-1'] = test => {
+    test.equal(resolveCharset('ISO-8859-1'), 'ISO-8859-1');
+    test.done();
+};
+
+module.exports['Charsets: resolves canonical windows-1252'] = test => {
+    test.equal(resolveCharset('windows-1252'), 'windows-1252');
+    test.done();
+};
+
+module.exports['Charsets: resolves canonical US-ASCII'] = test => {
+    test.equal(resolveCharset('US-ASCII'), 'US-ASCII');
+    test.done();
+};
+
+// ============================================
+// Alias resolution
+// ============================================
+
+module.exports['Charsets: resolves utf8 alias to UTF-8'] = test => {
+    test.equal(resolveCharset('utf8'), 'UTF-8');
+    test.done();
+};
+
+module.exports['Charsets: resolves win1252 alias to windows-1252'] = test => {
+    test.equal(resolveCharset('win1252'), 'windows-1252');
+    test.done();
+};
+
+module.exports['Charsets: resolves latin1 alias to ISO-8859-1'] = test => {
+    test.equal(resolveCharset('latin1'), 'ISO-8859-1');
+    test.done();
+};
+
+module.exports['Charsets: resolves ascii alias to US-ASCII'] = test => {
+    test.equal(resolveCharset('ascii'), 'US-ASCII');
+    test.done();
+};
+
+module.exports['Charsets: resolves usascii alias to US-ASCII'] = test => {
+    test.equal(resolveCharset('usascii'), 'US-ASCII');
+    test.done();
+};
+
+// ============================================
+// Case insensitivity
+// ============================================
+
+module.exports['Charsets: resolves lowercase utf-8 to UTF-8'] = test => {
+    test.equal(resolveCharset('utf-8'), 'UTF-8');
+    test.done();
+};
+
+module.exports['Charsets: resolves mixed-case Utf-8 to UTF-8'] = test => {
+    test.equal(resolveCharset('Utf-8'), 'UTF-8');
+    test.done();
+};
+
+module.exports['Charsets: resolves uppercase UTF8 (no separator) to UTF-8'] = test => {
+    test.equal(resolveCharset('UTF8'), 'UTF-8');
+    test.done();
+};
+
+// ============================================
+// Separator stripping
+// ============================================
+
+module.exports['Charsets: resolves ISO_8859_1 (underscores) to ISO-8859-1'] = test => {
+    test.equal(resolveCharset('ISO_8859_1'), 'ISO-8859-1');
+    test.done();
+};
+
+module.exports['Charsets: resolves windows_1252 (underscores) to windows-1252'] = test => {
+    test.equal(resolveCharset('windows_1252'), 'windows-1252');
+    test.done();
+};
+
+// ============================================
+// Japanese and CJK charsets
+// ============================================
+
+module.exports['Charsets: resolves ISO-2022-JP'] = test => {
+    test.equal(resolveCharset('ISO-2022-JP'), 'ISO-2022-JP');
+    test.done();
+};
+
+module.exports['Charsets: resolves Shift_JIS'] = test => {
+    test.equal(resolveCharset('Shift_JIS'), 'Shift_JIS');
+    test.done();
+};
+
+module.exports['Charsets: resolves EUC-JP'] = test => {
+    test.equal(resolveCharset('EUC-JP'), 'EUC-JP');
+    test.done();
+};
+
+module.exports['Charsets: resolves EUC-KR'] = test => {
+    test.equal(resolveCharset('EUC-KR'), 'EUC-KR');
+    test.done();
+};
+
+module.exports['Charsets: resolves GB2312'] = test => {
+    test.equal(resolveCharset('GB2312'), 'GB2312');
+    test.done();
+};
+
+module.exports['Charsets: resolves Big5'] = test => {
+    test.equal(resolveCharset('Big5'), 'Big5');
+    test.done();
+};
+
+module.exports['Charsets: resolves GBK'] = test => {
+    test.equal(resolveCharset('GBK'), 'GBK');
+    test.done();
+};
+
+// ============================================
+// Unknown charsets return null
+// ============================================
+
+module.exports['Charsets: returns null for unknown charset x-unknown'] = test => {
+    test.strictEqual(resolveCharset('x-unknown'), null);
+    test.done();
+};
+
+module.exports['Charsets: returns null for unknown charset bogus'] = test => {
+    test.strictEqual(resolveCharset('bogus'), null);
+    test.done();
+};
+
+module.exports['Charsets: returns null for empty string'] = test => {
+    test.strictEqual(resolveCharset(''), null);
+    test.done();
+};
+
+// ============================================
+// Invalid input throws TypeError
+// ============================================
+
+module.exports['Charsets: throws TypeError for null input'] = test => {
+    test.throws(() => resolveCharset(null));
+    test.done();
+};
+
+module.exports['Charsets: throws TypeError for undefined input'] = test => {
+    test.throws(() => resolveCharset(undefined));
+    test.done();
+};

package/test/commands-integration-test.js

@@ -8247,3 +8247,64 @@ module.exports['Commands: enable updates connection.enabled'] = async test => {
     test.ok(!connection.enabled.has('EXISTING')); // Old value should be gone
     test.done();
 };
+
+// ============================================
+// Download / DownloadMany Tests
+// ============================================
+
+const { ImapFlow } = require('../lib/imap-flow');
+
+module.exports['Commands: download returns empty when no mailbox selected'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+    // mailbox is not set by default
+    let result = await client.download('1', '1.2');
+    test.deepEqual(result, {});
+    test.done();
+};
+
+module.exports['Commands: downloadMany returns empty when no mailbox selected'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+    let result = await client.downloadMany('1', ['2', '3']);
+    test.deepEqual(result, {});
+    test.done();
+};
+
+module.exports['Commands: download with fetchOne returning null'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+    // Set mailbox so download doesn't return {} early
+    client.mailbox = { path: 'INBOX' };
+    // Mock fetchOne to return null (message not found)
+    client.fetchOne = async () => null;
+
+    // part '1' triggers the bodyStructure check path
+    let result = await client.download('1', '1');
+    test.equal(result.response, false);
+    test.equal(result.chunk, false);
+    test.done();
+};
+
+module.exports['Commands: downloadMany with fetchOne returning null'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+    client.mailbox = { path: 'INBOX' };
+    client.fetchOne = async () => null;
+
+    let result = await client.downloadMany('1', ['2', '3']);
+    test.equal(result.response, false);
+    test.done();
+};

package/test/connection-edge-cases-test.js

@@ -863,7 +863,7 @@ module.exports['Connection Edge: Close with empty locks array'] = test => {
     test.done();
 };
 
-module.exports['Connection Edge: Lock rejection is deferred via setImmediate'] = test => {
+module.exports['Connection Edge: Lock rejection happens synchronously during close'] = test => {
     let client = new ImapFlow({
         host: 'imap.example.com',
         port: 993,
@@ -871,7 +871,6 @@ module.exports['Connection Edge: Lock rejection is deferred via setImmediate'] =
     });
 
     let rejectionTime = null;
-    let closeTime = null;
 
     client.locks = [
         {
@@ -888,16 +887,10 @@ module.exports['Connection Edge: Lock rejection is deferred via setImmediate'] =
     client.usable = true;
 
     client.close();
-    closeTime = Date.now();
 
-    // Rejection should not have happened yet (synchronously)
-    test.equal(rejectionTime, null, 'Rejection should be deferred');
-
-    setImmediate(() => {
-        test.ok(rejectionTime !== null, 'Rejection should happen after setImmediate');
-        test.ok(rejectionTime >= closeTime, 'Rejection should happen after close()');
-        test.done();
-    });
+    // Rejection should have happened synchronously during close()
+    test.ok(rejectionTime !== null, 'Rejection should happen synchronously during close()');
+    test.done();
 };
 
 module.exports['Connection Edge: Pending requests and locks both rejected on close'] = test => {
@@ -940,11 +933,10 @@ module.exports['Connection Edge: Pending requests and locks both rejected on clo
 
     client.close();
 
-    setImmediate(() => {
-        test.ok(requestRejected, 'Pending request should be rejected');
-        test.ok(lockRejected, 'Pending lock should be rejected');
-        test.done();
-    });
+    // Rejections happen synchronously during close()
+    test.ok(requestRejected, 'Pending request should be rejected');
+    test.ok(lockRejected, 'Pending lock should be rejected');
+    test.done();
 };
 
 module.exports['Connection Edge: exec throws NoConnection when in LOGOUT state'] = async test => {
@@ -1569,3 +1561,97 @@ module.exports['Connection Edge: compress _deflate error after close does not cr
 
     test.done();
 };
+
+// ============================================
+// Mailbox Lock Tests
+// ============================================
+
+module.exports['Connection Edge: getMailboxLock queues lock in locks array'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // getMailboxLock should push to locks array then reject (no connection)
+    try {
+        await client.getMailboxLock('INBOX');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.ok(err);
+        test.equal(err.code, 'NoConnection');
+    }
+
+    test.done();
+};
+
+module.exports['Connection Edge: lockCounter increments with each getMailboxLock call'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    let initial = client.lockCounter;
+    let p1 = client.getMailboxLock('INBOX').catch(() => {});
+    let p2 = client.getMailboxLock('Sent').catch(() => {});
+
+    test.equal(client.lockCounter, initial + 2);
+
+    await Promise.all([p1, p2]);
+    test.done();
+};
+
+module.exports['Connection Edge: lock rejected when connection not usable'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // usable is false by default, no socket
+    try {
+        await client.getMailboxLock('INBOX');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.ok(err);
+        test.equal(err.code, 'NoConnection');
+        test.ok(err.message.includes('not available'));
+    }
+    test.done();
+};
+
+module.exports['Connection Edge: processLocks with empty locks array completes'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // processLocks with no pending locks should complete without error
+    await client.processLocks();
+    test.equal(client.processingLock, false);
+    test.done();
+};
+
+module.exports['Connection Edge: multiple locks rejected when no connection'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // Queue multiple locks, all should reject
+    let errors = [];
+    let p1 = client.getMailboxLock('INBOX').catch(err => errors.push(err));
+    let p2 = client.getMailboxLock('Sent').catch(err => errors.push(err));
+    let p3 = client.getMailboxLock('Drafts').catch(err => errors.push(err));
+
+    await Promise.all([p1, p2, p3]);
+
+    test.equal(errors.length, 3);
+    for (let err of errors) {
+        test.equal(err.code, 'NoConnection');
+    }
+    test.done();
+};

package/test/copyuid-parser-test.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const { parseCopyUid } = require('../lib/commands/copyuid-parser');
+
+/**
+ * Builds a minimal IMAP response object with a COPYUID-style section.
+ *
+ * @param {Array} section - Array of section elements with value properties
+ * @returns {Object} Response object suitable for parseCopyUid
+ */
+function makeResponse(section) {
+    return { attributes: [{ section }] };
+}
+
+// ============================================
+// Single UID pair
+// ============================================
+
+module.exports['CopyUID Parser: single UID pair sets uidValidity and uidMap entry'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '12345' }, { value: '1' }, { value: '100' }]), map);
+
+    test.equal(map.uidValidity, BigInt('12345'));
+    test.ok(map.uidMap instanceof Map);
+    test.equal(map.uidMap.get(1), 100);
+    test.equal(map.uidMap.size, 1);
+    test.done();
+};
+
+// ============================================
+// UID ranges
+// ============================================
+
+module.exports['CopyUID Parser: contiguous UID range maps all source UIDs to destinations'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '99' }, { value: '1:3' }, { value: '10:12' }]), map);
+
+    test.equal(map.uidValidity, BigInt('99'));
+    test.ok(map.uidMap instanceof Map);
+    test.equal(map.uidMap.size, 3);
+    test.equal(map.uidMap.get(1), 10);
+    test.equal(map.uidMap.get(2), 11);
+    test.equal(map.uidMap.get(3), 12);
+    test.done();
+};
+
+// ============================================
+// Comma-separated UIDs
+// ============================================
+
+module.exports['CopyUID Parser: comma-separated UIDs map each source to its destination'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '200' }, { value: '1,5,9' }, { value: '100,105,109' }]), map);
+
+    test.equal(map.uidMap.size, 3);
+    test.equal(map.uidMap.get(1), 100);
+    test.equal(map.uidMap.get(5), 105);
+    test.equal(map.uidMap.get(9), 109);
+    test.done();
+};
+
+// ============================================
+// Non-COPYUID response code
+// ============================================
+
+module.exports['CopyUID Parser: non-COPYUID response code leaves map unchanged'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'APPENDUID' }, { value: '12345' }, { value: '1' }, { value: '100' }]), map);
+
+    test.equal(map.uidValidity, undefined);
+    test.equal(map.uidMap, undefined);
+    test.done();
+};
+
+// ============================================
+// Missing / malformed input
+// ============================================
+
+module.exports['CopyUID Parser: missing attributes leaves map unchanged'] = test => {
+    let map = {};
+    parseCopyUid({}, map);
+
+    test.equal(map.uidValidity, undefined);
+    test.equal(map.uidMap, undefined);
+    test.done();
+};
+
+module.exports['CopyUID Parser: empty attributes array leaves map unchanged'] = test => {
+    let map = {};
+    parseCopyUid({ attributes: [] }, map);
+
+    test.equal(map.uidValidity, undefined);
+    test.equal(map.uidMap, undefined);
+    test.done();
+};
+
+module.exports['CopyUID Parser: null section leaves map unchanged'] = test => {
+    let map = {};
+    parseCopyUid({ attributes: [{ section: null }] }, map);
+
+    test.equal(map.uidValidity, undefined);
+    test.equal(map.uidMap, undefined);
+    test.done();
+};
+
+// ============================================
+// Non-numeric uidValidity
+// ============================================
+
+module.exports['CopyUID Parser: non-numeric uidValidity skips uidValidity but still builds uidMap'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: 'abc' }, { value: '1' }, { value: '100' }]), map);
+
+    test.equal(map.uidValidity, undefined);
+    test.ok(map.uidMap instanceof Map);
+    test.equal(map.uidMap.get(1), 100);
+    test.done();
+};
+
+// ============================================
+// Mismatched source/destination lengths
+// ============================================
+
+module.exports['CopyUID Parser: mismatched source and destination lengths sets uidValidity but skips uidMap'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '12345' }, { value: '1:3' }, { value: '10' }]), map);
+
+    test.equal(map.uidValidity, BigInt('12345'));
+    test.equal(map.uidMap, undefined);
+    test.done();
+};
+
+// ============================================
+// Large uidValidity
+// ============================================
+
+module.exports['CopyUID Parser: large uidValidity is stored as BigInt'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '999999999999' }, { value: '1' }, { value: '100' }]), map);
+
+    test.equal(map.uidValidity, BigInt('999999999999'));
+    test.done();
+};
+
+module.exports['CopyUID Parser: uidValidity zero is stored as BigInt(0)'] = test => {
+    let map = {};
+    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '0' }, { value: '1' }, { value: '100' }]), map);
+
+    test.strictEqual(map.uidValidity, BigInt(0));
+    test.ok(map.uidMap instanceof Map);
+    test.equal(map.uidMap.get(1), 100);
+    test.done();
+};

package/test/imap-compiler-test.js

@@ -441,3 +441,69 @@ module.exports['IMAP Compiler: LITERAL byte length'] = test =>
             '* CMD "(* 10B literal *)" "Vana kere"'
         )
     );
+
+module.exports['IMAP Compiler: MongoDB binary object is unwrapped'] = test =>
+    asyncWrapper(test, async test => {
+        // Create a non-Buffer object with a .buffer property (simulates MongoDB Binary)
+        const mongoBinary = { buffer: Buffer.from('test data') };
+        const compiled = (
+            await compiler({
+                tag: '*',
+                command: 'CMD',
+                attributes: [mongoBinary]
+            })
+        ).toString();
+        // The buffer content should appear in the output (unwrapped from the MongoDB binary wrapper)
+        test.ok(compiled.includes('test data'), 'should contain the buffer content after unwrapping');
+        test.ok(compiled.includes('CMD'), 'should contain command');
+    });
+
+module.exports['IMAP Compiler: long string truncated in logging mode'] = test =>
+    asyncWrapper(test, async test => {
+        const longString = 'x'.repeat(150);
+        const compiled = (
+            await compiler(
+                {
+                    tag: '*',
+                    command: 'CMD',
+                    attributes: [longString]
+                },
+                { asArray: false, isLogging: true }
+            )
+        ).toString();
+        test.ok(compiled.includes('150B string'), 'should show byte count instead of content');
+        test.ok(!compiled.includes('x'.repeat(150)), 'should not contain the full string');
+    });
+
+module.exports['IMAP Compiler: literal truncated in logging mode'] = test =>
+    asyncWrapper(test, async test => {
+        const compiled = (
+            await compiler(
+                {
+                    tag: '*',
+                    command: 'CMD',
+                    attributes: [{ type: 'LITERAL', value: Buffer.alloc(200) }]
+                },
+                { asArray: false, isLogging: true }
+            )
+        ).toString();
+        test.ok(compiled.includes('200B literal'), 'should show byte count for literal');
+    });
+
+module.exports['IMAP Compiler: partial range in SECTION'] = test =>
+    asyncWrapper(test, async test => {
+        const compiled = (
+            await compiler({
+                tag: '*',
+                command: 'CMD',
+                attributes: [
+                    {
+                        type: 'SECTION',
+                        section: [{ type: 'ATOM', value: 'BODY' }],
+                        partial: [0, 50]
+                    }
+                ]
+            })
+        ).toString();
+        test.ok(compiled.includes('<0.50>'), 'should contain partial range <0.50>');
+    });