imapflow 1.2.13 → 1.2.15

package/test/tools-test.js

@@ -270,6 +270,13 @@ module.exports['Tools: getFlagColor with color bits'] = test => {
     test.done();
 };
 
+module.exports['Tools: getFlagColor with all bits set (index 7) defaults to red'] = test => {
+    // bit0=1, bit1=2, bit2=4 => color=7, FLAG_COLORS[7] is undefined => defaults to 'red'
+    let flags = new Set(['\\Flagged', '$MailFlagBit0', '$MailFlagBit1', '$MailFlagBit2']);
+    test.equal(tools.getFlagColor(flags), 'red');
+    test.done();
+};
+
 // ============================================
 // getColorFlags tests
 // ============================================
@@ -284,11 +291,11 @@ module.exports['Tools: getColorFlags with valid color'] = test => {
 };
 
 module.exports['Tools: getColorFlags with red (index 0)'] = test => {
-    // 'red' is index 0, which is falsy in JS - removes \\Flagged
+    // 'red' is index 0 — should add \\Flagged and remove all MailFlagBit flags
     let result = tools.getColorFlags('red');
     test.ok(Array.isArray(result.add));
     test.ok(Array.isArray(result.remove));
-    test.ok(result.remove.includes('\\Flagged'));
+    test.ok(result.add.includes('\\Flagged'));
     test.done();
 };
 
@@ -990,3 +997,143 @@ module.exports['Tools: AuthenticationFailure error class'] = test => {
     test.equal(error.message, 'Auth failed');
     test.done();
 };
+
+// ============================================
+// enhanceCommandError tests
+// ============================================
+
+module.exports['Tools: enhanceCommandError sets serverResponseCode'] = async test => {
+    let err = new Error('Command failed');
+    err.response = {
+        tag: '*',
+        command: 'NO',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [{ type: 'ATOM', value: 'NONEXISTENT' }]
+            },
+            { type: 'ATOM', value: 'Mailbox' },
+            { type: 'ATOM', value: 'not' },
+            { type: 'ATOM', value: 'found' }
+        ]
+    };
+    let result = await tools.enhanceCommandError(err);
+    test.equal(result.serverResponseCode, 'NONEXISTENT');
+    test.equal(typeof result.response, 'string');
+    test.done();
+};
+
+module.exports['Tools: enhanceCommandError with no status code'] = async test => {
+    let err = new Error('Command failed');
+    err.response = { tag: '*', command: 'NO' };
+    let result = await tools.enhanceCommandError(err);
+    test.ok(!result.serverResponseCode);
+    test.done();
+};
+
+module.exports['Tools: enhanceCommandError with null response'] = async test => {
+    let err = new Error('Command failed');
+    err.response = null;
+    let result = await tools.enhanceCommandError(err);
+    test.equal(result.response, false);
+    test.done();
+};
+
+// ============================================
+// getDecoder additional tests
+// ============================================
+
+module.exports['Tools: getDecoder with eucjp charset'] = test => {
+    let decoder = tools.getDecoder('eucjp');
+    test.ok(decoder);
+    test.equal(decoder.constructor.name, 'JPDecoder');
+    test.done();
+};
+
+module.exports['Tools: getDecoder with euc-jp (hyphenated) returns JPDecoder'] = test => {
+    let decoder = tools.getDecoder('euc-jp');
+    test.ok(decoder);
+    test.equal(decoder.constructor.name, 'JPDecoder');
+    test.done();
+};
+
+module.exports['Tools: getDecoder with jis charset'] = test => {
+    let decoder = tools.getDecoder('jis');
+    test.ok(decoder);
+    test.equal(decoder.constructor.name, 'JPDecoder');
+    test.done();
+};
+
+module.exports['Tools: getDecoder with windows-1252 returns iconv stream'] = test => {
+    let decoder = tools.getDecoder('windows-1252');
+    test.ok(decoder);
+    test.notEqual(decoder.constructor.name, 'JPDecoder');
+    test.ok(typeof decoder.write === 'function');
+    test.done();
+};
+
+module.exports['Tools: getDecoder with no arg defaults to ascii'] = test => {
+    let decoder = tools.getDecoder();
+    test.ok(decoder);
+    test.ok(typeof decoder.write === 'function');
+    test.done();
+};
+
+// ============================================
+// getColorFlags tests
+// ============================================
+
+module.exports['Tools: getColorFlags returns non-null for all valid colors'] = test => {
+    let colors = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'grey'];
+    for (let color of colors) {
+        let result = tools.getColorFlags(color);
+        test.ok(result, `getColorFlags('${color}') should not be null`);
+        test.ok(Array.isArray(result.add), `${color} should have add array`);
+        test.ok(Array.isArray(result.remove), `${color} should have remove array`);
+    }
+    test.done();
+};
+
+module.exports['Tools: getColorFlags red has Flagged but no MailFlagBit set'] = test => {
+    let result = tools.getColorFlags('red');
+    // red = index 0, all bits 0 — adds \\Flagged, removes all MailFlagBit flags
+    test.ok(result.add.includes('\\Flagged'));
+    test.ok(result.remove.includes('$MailFlagBit0'));
+    test.ok(result.remove.includes('$MailFlagBit1'));
+    test.ok(result.remove.includes('$MailFlagBit2'));
+    test.done();
+};
+
+module.exports['Tools: getColorFlags orange has MailFlagBit0 set'] = test => {
+    let result = tools.getColorFlags('orange');
+    // orange = index 1, bit 0 set
+    test.ok(result.add.includes('\\Flagged'));
+    test.ok(result.add.includes('$MailFlagBit0'));
+    test.ok(result.remove.includes('$MailFlagBit1'));
+    test.ok(result.remove.includes('$MailFlagBit2'));
+    test.done();
+};
+
+module.exports['Tools: getColorFlags yellow has MailFlagBit1 set'] = test => {
+    let result = tools.getColorFlags('yellow');
+    // yellow = index 2, bit 1 set
+    test.ok(result.add.includes('\\Flagged'));
+    test.ok(result.add.includes('$MailFlagBit1'));
+    test.ok(result.remove.includes('$MailFlagBit0'));
+    test.ok(result.remove.includes('$MailFlagBit2'));
+    test.done();
+};
+
+module.exports['Tools: getColorFlags returns null for invalid color'] = test => {
+    test.equal(tools.getColorFlags('invalid'), null);
+    test.equal(tools.getColorFlags('pink'), null);
+    test.done();
+};
+
+module.exports['Tools: getColorFlags with null returns result not null'] = test => {
+    // null input: colorCode becomes null, which is not < 0, so it falls through
+    let result = tools.getColorFlags(null);
+    test.ok(result);
+    test.ok(result.remove.includes('\\Flagged'));
+    test.done();
+};

package/test/unhandled-rejection-test.js

@@ -3,10 +3,11 @@
 /**
  * Tests for unhandled rejection prevention.
  *
- * When close() runs, it rejects pending promises via setImmediate. Without
- * guards, the rejection can fire before the caller's handler is attached,
- * causing Node.js unhandledRejection. These tests verify that no unhandled
- * rejections escape while the caller still receives the expected error.
+ * When close() runs, it rejects pending promises synchronously. exec() and
+ * getMailboxLock() attach .catch(noop) before returning, so the rejection is
+ * observed immediately and does not trigger Node.js unhandledRejection.
+ * These tests verify that no unhandled rejections escape while the caller
+ * still receives the expected error.
  *
  * Key fix: exec() and getMailboxLock() are non-async, returning the promise
  * directly (with .catch(noop)), so the caller gets the same promise object
@@ -18,8 +19,13 @@
 const net = require('net');
 const { ImapFlow } = require('../lib/imap-flow');
 
-// Create a simple mock IMAP server
-function createMockServer() {
+// Create a mock IMAP server with optional custom behavior.
+// options.extraCapabilities - additional capabilities (e.g., 'IDLE')
+// options.onCommand(socket, tag, command) - custom handler; return true if handled
+function createMockServer(options) {
+    const extraCaps = options && options.extraCapabilities ? ' ' + options.extraCapabilities : '';
+    const onCommand = options && options.onCommand;
+
     const server = net.createServer(socket => {
         socket.write('* OK Mock IMAP Server ready\r\n');
 
@@ -34,8 +40,12 @@ function createMockServer() {
                 const tag = parts[0];
                 const command = parts[1] ? parts[1].toUpperCase() : '';
 
+                if (onCommand && onCommand(socket, tag, command, line)) {
+                    continue;
+                }
+
                 if (command === 'CAPABILITY') {
-                    socket.write('* CAPABILITY IMAP4rev1 AUTH=PLAIN\r\n');
+                    socket.write(`* CAPABILITY IMAP4rev1 AUTH=PLAIN${extraCaps}\r\n`);
                     socket.write(`${tag} OK CAPABILITY completed\r\n`);
                 } else if (command === 'LOGIN') {
                     socket.write(`${tag} OK LOGIN completed\r\n`);
@@ -53,6 +63,12 @@ function createMockServer() {
                 } else if (command === 'ID') {
                     socket.write('* ID NIL\r\n');
                     socket.write(`${tag} OK ID completed\r\n`);
+                } else if (command === 'SELECT' || command === 'EXAMINE') {
+                    socket.write('* 1 EXISTS\r\n');
+                    socket.write('* 1 RECENT\r\n');
+                    socket.write('* OK [UIDVALIDITY 1] UIDs valid\r\n');
+                    socket.write('* OK [UIDNEXT 2] Predicted next UID\r\n');
+                    socket.write(`${tag} OK SELECT completed\r\n`);
                 } else if (command === 'NOOP') {
                     socket.write(`${tag} OK NOOP completed\r\n`);
                 } else if (tag && command) {
@@ -103,9 +119,8 @@ exports['Unhandled Rejection Prevention'] = {
         const detector = installRejectionDetector(test);
 
         // Create a pending request, then immediately close.
-        // close() rejects the request via setImmediate. Without the fix,
-        // trySend()'s async chain rejects the promise through a microtask
-        // before the caller's handler is attached.
+        // close() rejects the request synchronously. The .catch(noop) on the
+        // exec() promise ensures the rejection is observed immediately.
         let promise = client.exec('NOOP');
         client.close();
 
@@ -246,7 +261,7 @@ exports['Unhandled Rejection Prevention'] = {
                 await client.connect();
 
                 // Request a lock, then immediately close before it resolves.
-                // close() rejects pending locks via setImmediate.
+                // close() rejects pending locks synchronously.
                 let lockPromise = client.getMailboxLock('INBOX');
                 client.close();
 
@@ -323,5 +338,129 @@ exports['Unhandled Rejection Prevention'] = {
                 }
             );
         });
+    },
+
+    'BYE during IDLE should not cause unhandled rejection (Death 1)'(test) {
+        test.expect(2);
+
+        const server = createMockServer({
+            extraCapabilities: 'IDLE',
+            onCommand(socket, tag, command) {
+                if (command === 'IDLE') {
+                    socket.write('+ idling\r\n');
+                    // After a short delay, send BYE and close (simulates token expiry)
+                    setTimeout(() => {
+                        try {
+                            socket.write('* BYE Session invalidated - AccessTokenExpired\r\n');
+                            socket.end();
+                        } catch {
+                            // socket may already be closed
+                        }
+                    }, 50);
+                    return true;
+                }
+            }
+        });
+
+        server.listen(0, '127.0.0.1', async () => {
+            const port = server.address().port;
+
+            const client = new ImapFlow({
+                host: '127.0.0.1',
+                port,
+                secure: false,
+                logger: false,
+                auth: {
+                    user: 'test',
+                    pass: 'test'
+                }
+            });
+
+            const detector = installRejectionDetector(test);
+
+            try {
+                await client.connect();
+                await client.mailboxOpen('INBOX');
+
+                // Start IDLE and wait for the BYE-triggered close
+                await new Promise((resolve, reject) => {
+                    client.idle().catch(() => {
+                        // Expected: IDLE rejects when BYE arrives
+                    });
+
+                    client.on('close', () => {
+                        // Wait for any deferred unhandled rejections to surface
+                        setTimeout(resolve, 100);
+                    });
+
+                    // Safety timeout
+                    setTimeout(() => reject(new Error('Timeout waiting for close')), 5000);
+                });
+
+                detector.check();
+                test.ok(true, 'No unhandled rejection during IDLE + BYE');
+            } catch (err) {
+                detector.check();
+                test.ok(false, 'Unexpected error: ' + err.message);
+            } finally {
+                server.close(() => test.done());
+            }
+        });
+    },
+
+    'BAD response to FETCH should not cause unhandled rejection (Death 2)'(test) {
+        test.expect(3);
+
+        const server = createMockServer({
+            onCommand(socket, tag, command) {
+                if (command === 'UID' || command === 'FETCH') {
+                    // Simulate "Server Unavailable" error for any FETCH variant
+                    socket.write(`${tag} BAD Server Unavailable. 15\r\n`);
+                    return true;
+                }
+            }
+        });
+
+        server.listen(0, '127.0.0.1', async () => {
+            const port = server.address().port;
+
+            const client = new ImapFlow({
+                host: '127.0.0.1',
+                port,
+                secure: false,
+                logger: false,
+                auth: {
+                    user: 'test',
+                    pass: 'test'
+                }
+            });
+
+            const detector = installRejectionDetector(test);
+
+            try {
+                await client.connect();
+                await client.mailboxOpen('INBOX');
+
+                // Attempt a FETCH that will get BAD response
+                try {
+                    await client.fetchOne('*', { uid: true }, { uid: true });
+                    test.ok(false, 'fetchOne should have rejected');
+                } catch (err) {
+                    test.equal(err.message, 'Command failed', 'Should get Command failed error');
+                    test.equal(err.responseStatus, 'BAD', 'Response status should be BAD');
+                }
+
+                // Wait for any deferred unhandled rejections
+                await new Promise(r => setTimeout(r, 100));
+                detector.check();
+
+                client.close();
+            } catch (err) {
+                detector.check();
+                test.ok(false, 'Unexpected error: ' + err.message);
+            } finally {
+                server.close(() => test.done());
+            }
+        });
     }
 };