imapflow 1.4.9 → 1.6.0

package/lib/tools.js

@@ -19,9 +19,10 @@ const EXPANDED_RANGE_LIMIT = 0x1000000;
 // Extensions that RFC 9051 (IMAP4rev2) folds into the base protocol (Appendix E).
 // When IMAP4rev2 is active, these are available even without their own capability
 // token. BINARY is deliberately excluded - RFC 9051 only folds in the FETCH side,
-// and the BINARY consumers have safe fallbacks of their own. The set mirrors the
-// Appendix E list in full, including entries no call site consults yet, so any
-// future capability check gets the rev2 folding for free.
+// which fetch.js handles with its own isRev2Active check, while the APPEND side
+// stays gated on the BINARY token. The set mirrors the Appendix E list in full,
+// including entries no call site consults yet, so any future capability check
+// gets the rev2 folding for free.
 const IMAP4REV2_FOLDED_CAPABILITIES = new Set([
     'ENABLE',
     'ESEARCH',
@@ -47,6 +48,23 @@ class AuthenticationFailure extends Error {
 }
 
 const tools = {
+    /**
+     * Detaches a background timer from the event loop, so it cannot keep the process alive on its
+     * own. Applied to every background timer (auto-IDLE, IDLE restart, fallback polling, throttle
+     * back-off, held-lock diagnostics); connection and greeting deadlines are deliberately left
+     * attached, because a caller is waiting for connect() to settle.
+     *
+     * @param {Object} timer - Timer handle returned by setTimeout
+     * @returns {Object} The same timer handle
+     */
+    unrefTimer(timer) {
+        /* c8 ignore next 3 */ // node timers always expose unref(); the guard covers replaced globals in tests
+        if (timer && typeof timer.unref === 'function') {
+            timer.unref();
+        }
+        return timer;
+    },
+
     /**
      * Checks whether IMAP4rev2 semantics are active for the connection: either the
      * client enabled IMAP4rev2 explicitly, or the server is rev2-only (advertises
@@ -115,6 +133,24 @@ const tools = {
                         attributes.push({ type: 'ATOM', value: key.toUpperCase() });
                     }
                     break;
+
+                case 'SIZE':
+                    // STATUS SIZE requires the STATUS=SIZE extension (RFC 8438), which
+                    // RFC 9051 folds into base IMAP4rev2
+                    if (tools.hasCapability(connection, 'STATUS=SIZE')) {
+                        attributes.push({ type: 'ATOM', value: key.toUpperCase() });
+                    }
+                    break;
+
+                case 'DELETED':
+                    // STATUS DELETED is a base IMAP4rev2 addition (RFC 9051 Appendix E
+                    // item 3) with no standalone capability - requesting it from a plain
+                    // rev1 server would get the whole STATUS request rejected. RFC 9208
+                    // additionally makes it mandatory when QUOTA=RES-MESSAGE is advertised.
+                    if (tools.isRev2Active(connection) || connection.capabilities.has('QUOTA=RES-MESSAGE')) {
+                        attributes.push({ type: 'ATOM', value: key.toUpperCase() });
+                    }
+                    break;
             }
         });
 
@@ -591,6 +627,19 @@ const tools = {
                             map.bodyParts = new Map();
                         }
                         map.bodyParts.set(partKey, value);
+
+                        if (match[1].toLowerCase() === 'binary') {
+                            // The part arrived via FETCH BINARY (RFC 3516, FETCH side folded
+                            // into IMAP4rev2), so the server has already removed the
+                            // content-transfer-encoding - consumers must not decode it again.
+                            // Recorded from the actual response, not predicted from the
+                            // request, so it stays correct even if a server answers a BINARY
+                            // request with a BODY response or vice versa.
+                            if (!map.binaryParts) {
+                                map.binaryParts = new Set();
+                            }
+                            map.binaryParts.add(partKey);
+                        }
                         break;
                     }
                     break;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.4.9",
+    "version": "1.6.0",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",
@@ -10,6 +10,7 @@
         "test:rev2": "bash test/integration/run-rev2-tests.sh",
         "update": "rm -rf node_modules package-lock.json && ncu -u && npm install",
         "format": "prettier --write \"**/*.{js,json,md,yml,yaml}\" --ignore-path .prettierignore",
+        "format:check": "prettier --check \"**/*.{js,json,md,yml,yaml}\" --ignore-path .prettierignore",
         "lint": "eslint ."
     },
     "repository": {
@@ -49,7 +50,6 @@
         "libbase64": "1.3.0",
         "libmime": "5.4.1",
         "libqp": "2.1.1",
-        "nodemailer": "9.0.3",
         "pino": "10.3.1",
         "socks": "2.8.9"
     }

package/test/commands-branches-test.js

@@ -10,6 +10,8 @@
 // The mock connection factory mirrors the one in commands-integration-test.js.
 // ============================================================================
 
+const imapCommands = require('../lib/imap-commands.js');
+
 const createMockConnection = (overrides = {}) => {
     const states = {
         NOT_AUTHENTICATED: 1,
@@ -29,7 +31,7 @@ const createMockConnection = (overrides = {}) => {
         noModseq: false
     };
 
-    return {
+    const connection = {
         states,
         state: overrides.state || states.SELECTED,
         id: 'test-connection-id',
@@ -51,10 +53,22 @@ const createMockConnection = (overrides = {}) => {
         emit: overrides.emit || (() => {}),
         write: overrides.write || (() => {}),
         currentSelectCommand: false,
+        // A live transport: command implementations that guard against polling or writing on a
+        // dead connection (idle.js) need this to look established.
+        socket: overrides.socket || { destroyed: false },
         messageFlagsAdd: overrides.messageFlagsAdd || (async () => {}),
         messageCopy: overrides.messageCopy || (async () => {}),
         messageDelete: overrides.messageDelete || (async () => {}),
         run: overrides.run || (async () => {}),
+        // Mirrors ImapFlow.runInternal(): dispatch through the command registry without the
+        // preCheck/auto-IDLE handshake that run() performs, so a fallback poll runs the real
+        // SELECT/STATUS implementation.
+        runInternal:
+            overrides.runInternal ||
+            (async (command, ...args) => {
+                let handler = imapCommands.get(command.toUpperCase());
+                return handler ? await handler(connection, ...args) : false;
+            }),
         exec:
             overrides.exec ||
             (async () => ({
@@ -63,6 +77,8 @@ const createMockConnection = (overrides = {}) => {
             })),
         ...overrides
     };
+
+    return connection;
 };
 
 // ============================================================================

package/test/commands-integration-test.js

@@ -7,6 +7,8 @@
 // Mock Connection Factory
 // ============================================
 
+const imapCommands = require('../lib/imap-commands.js');
+
 const createMockConnection = (overrides = {}) => {
     const states = {
         NOT_AUTHENTICATED: 1,
@@ -26,7 +28,7 @@ const createMockConnection = (overrides = {}) => {
         noModseq: false
     };
 
-    return {
+    const connection = {
         states,
         state: overrides.state || states.SELECTED,
         id: 'test-connection-id',
@@ -48,6 +50,9 @@ const createMockConnection = (overrides = {}) => {
         },
         close: overrides.close || (() => {}),
         emit: overrides.emit || (() => {}),
+        // A live transport: command implementations that guard against polling or writing on a
+        // dead connection (idle.js) need this to look established.
+        socket: overrides.socket || { destroyed: false },
         currentSelectCommand: false,
         skipListSubscribedArg: false,
         skipListStatusArgs: false,
@@ -55,6 +60,15 @@ const createMockConnection = (overrides = {}) => {
         skipLsub: false,
         messageFlagsAdd: overrides.messageFlagsAdd || (async () => {}),
         run: overrides.run || (async () => {}),
+        // Mirrors ImapFlow.runInternal(): dispatch through the command registry without the
+        // preCheck/auto-IDLE handshake that run() performs, so a fallback poll runs the real
+        // SELECT/STATUS implementation.
+        runInternal:
+            overrides.runInternal ||
+            (async (command, ...args) => {
+                let handler = imapCommands.get(command.toUpperCase());
+                return handler ? await handler(connection, ...args) : false;
+            }),
         exec:
             overrides.exec ||
             (async () => ({
@@ -63,6 +77,8 @@ const createMockConnection = (overrides = {}) => {
             })),
         ...overrides
     };
+
+    return connection;
 };
 
 // Decodes the base64 SASL payload that authenticate() hands to exec().
@@ -488,6 +504,33 @@ module.exports['Commands: search collects results from an ESEARCH reply to plain
     test.done();
 };
 
+module.exports['Commands: search returns empty array for an ESEARCH reply without ALL'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            // RFC 9051: an ESEARCH response with no matches omits the ALL item
+            if (opts && opts.untagged && opts.untagged.ESEARCH) {
+                await opts.untagged.ESEARCH({
+                    attributes: [
+                        [
+                            { type: 'ATOM', value: 'TAG' },
+                            { type: 'STRING', value: 'A282' }
+                        ],
+                        { type: 'ATOM', value: 'COUNT' },
+                        { type: 'ATOM', value: '0' }
+                    ]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, []);
+    test.done();
+};
+
 module.exports['Commands: search caps a hostile ESEARCH ALL range at the mailbox size'] = async test => {
     const connection = createMockConnection({
         state: 3,
@@ -693,6 +736,26 @@ module.exports['Commands: store add flags'] = async test => {
     test.done();
 };
 
+module.exports['Commands: store drops the Recent flag from the wire'] = async test => {
+    let execArgs = null;
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs) => {
+            execArgs = { cmd, attrs };
+            return { next: () => {} };
+        }
+    });
+
+    // \Recent is owned by the server (and removed entirely in IMAP4rev2) - a
+    // client-side STORE must never try to set it
+    const result = await storeCommand(connection, '1:10', ['\\Seen', '\\Recent'], { operation: 'add' });
+    test.equal(result, true);
+    const attrsStr = JSON.stringify(execArgs.attrs);
+    test.ok(attrsStr.includes('\\\\Seen'));
+    test.ok(!attrsStr.toLowerCase().includes('recent'));
+    test.done();
+};
+
 module.exports['Commands: store remove flags'] = async test => {
     let execArgs = null;
     const connection = createMockConnection({
@@ -2975,6 +3038,97 @@ module.exports['Commands: fetch with BINARY capability'] = async test => {
     test.done();
 };
 
+module.exports['Commands: fetch with binary uses BINARY on rev2-only servers without the token'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        // rev2-only server: no BINARY token, but RFC 9051 folds the FETCH side of
+        // the BINARY extension into base IMAP4rev2
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs) => {
+            queryAttrs = attrs;
+            return { next: () => {} };
+        }
+    });
+
+    await fetchCommand(connection, '1', { source: true }, { binary: true });
+    test.ok(queryAttrs);
+    test.ok(JSON.stringify(queryAttrs).includes('BINARY.PEEK'));
+    test.done();
+};
+
+module.exports['Commands: fetch with binary keeps BODY for non-numeric sections'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['BINARY', true]]),
+        exec: async (cmd, attrs) => {
+            queryAttrs = attrs;
+            return { next: () => {} };
+        }
+    });
+
+    // RFC 3516/RFC 9051: section-binary only allows numeric part specifiers -
+    // BINARY[HEADER], BINARY[TEXT] and BINARY[n.MIME] are invalid syntax that
+    // servers reject, so those sections must stay BODY fetches even with
+    // options.binary set
+    await fetchCommand(connection, '1', { headers: true, bodyParts: ['TEXT', '1.MIME', '1.2'] }, { binary: true });
+    test.ok(queryAttrs);
+    const sections = [];
+    const walk = list => {
+        for (let entry of Array.isArray(list) ? list : [list]) {
+            if (Array.isArray(entry)) {
+                walk(entry);
+            } else if (entry && entry.section) {
+                sections.push({ value: entry.value, section: entry.section.length ? entry.section[0].value : '' });
+            }
+        }
+    };
+    walk(queryAttrs);
+
+    for (let entry of sections) {
+        if (['HEADER', 'TEXT', '1.MIME'].includes(entry.section)) {
+            test.equal(entry.value, 'BODY.PEEK', `${entry.section} must be fetched via BODY.PEEK`);
+        }
+        if (entry.section === '1.2') {
+            test.equal(entry.value, 'BINARY.PEEK', 'numeric part specifiers may use BINARY.PEEK');
+        }
+    }
+    test.ok(
+        sections.some(entry => entry.section === '1.2'),
+        'numeric body part present'
+    );
+    test.ok(
+        sections.some(entry => entry.section === 'TEXT'),
+        'TEXT body part present'
+    );
+    test.done();
+};
+
+module.exports['Commands: fetch with binary keeps BODY on unenabled dual rev1+rev2 servers'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        // dual server without ENABLE IMAP4rev2 - rev2 semantics are not active, so
+        // the BINARY fold must not apply
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['IMAP4rev2', true]
+        ]),
+        exec: async (cmd, attrs) => {
+            queryAttrs = attrs;
+            return { next: () => {} };
+        }
+    });
+
+    await fetchCommand(connection, '1', { source: true }, { binary: true });
+    test.ok(queryAttrs);
+    const queryStr = JSON.stringify(queryAttrs);
+    test.ok(queryStr.includes('BODY.PEEK'));
+    test.ok(!queryStr.includes('BINARY.PEEK'));
+    test.done();
+};
+
 module.exports['Commands: fetch with OBJECTID capability'] = async test => {
     let queryAttrs = null;
     const connection = createMockConnection({
@@ -3453,6 +3607,71 @@ module.exports['Commands: list with statusQuery'] = async test => {
     test.done();
 };
 
+module.exports['Commands: list statusQuery parses inline SIZE and DELETED on rev2 sessions'] = async test => {
+    let listAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST') {
+                listAttrs = attrs;
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    });
+                }
+                if (opts && opts.untagged && opts.untagged.STATUS) {
+                    await opts.untagged.STATUS({
+                        attributes: [
+                            { value: 'INBOX' },
+                            [{ value: 'MESSAGES' }, { value: '10' }, { value: 'SIZE' }, { value: '12345678901234' }, { value: 'DELETED' }, { value: '3' }]
+                        ]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*', {
+        statusQuery: { messages: true, size: true, deleted: true }
+    });
+    const attrsStr = JSON.stringify(listAttrs);
+    test.ok(attrsStr.includes('SIZE'));
+    test.ok(attrsStr.includes('DELETED'));
+    const inbox = result.find(entry => entry.path === 'INBOX');
+    test.ok(inbox);
+    test.equal(inbox.status.messages, 10);
+    // STATUS SIZE is a number64 - values beyond 2^32 must survive
+    test.strictEqual(inbox.status.size, 12345678901234);
+    test.strictEqual(inbox.status.deleted, 3);
+    test.done();
+};
+
+module.exports['Commands: list tolerates an OLDNAME extended data item'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // RFC 9051 6.3.9.7: a LIST response may carry an OLDNAME extended
+                // data item after a RENAME or name normalization - the client must
+                // parse the response without choking on the extra attribute
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'NewBox' }, [{ value: 'OLDNAME' }, [{ value: 'OldBox' }]]]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    const entry = result.find(folder => folder.path === 'NewBox');
+    test.ok(entry, 'mailbox with OLDNAME extended data must be listed');
+    test.ok(entry.flags.has('\\HasNoChildren'));
+    test.done();
+};
+
 module.exports['Commands: list with CONDSTORE status query'] = async test => {
     let listAttrs = null;
     const connection = createMockConnection({
@@ -5742,6 +5961,108 @@ module.exports['Commands: status merges synthetic recent into rev2 query results
     test.done();
 };
 
+module.exports['Commands: status requests and parses SIZE and DELETED on rev2 sessions'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        // rev2-only server: STATUS=SIZE is folded in and DELETED is a base rev2
+        // status item (RFC 9051 Appendix E item 3)
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [
+                    { value: 'INBOX' },
+                    [{ value: 'MESSAGES' }, { value: '100' }, { value: 'SIZE' }, { value: '12345678901234' }, { value: 'DELETED' }, { value: '3' }]
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { messages: true, size: true, deleted: true });
+    test.ok(queryAttrs.includes('SIZE'));
+    test.ok(queryAttrs.includes('DELETED'));
+    test.equal(result.messages, 100);
+    // STATUS SIZE is a number64 - values beyond 2^32 must survive
+    test.strictEqual(result.size, 12345678901234);
+    test.strictEqual(result.deleted, 3);
+    test.done();
+};
+
+module.exports['Commands: status requests SIZE with the STATUS=SIZE token on rev1 sessions'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        // RFC 8438 server: SIZE is available via the capability token, DELETED is
+        // rev2-only and must be dropped
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['STATUS=SIZE', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'SIZE' }, { value: '2048' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { size: true, deleted: true });
+    test.ok(queryAttrs.includes('SIZE'));
+    test.ok(!queryAttrs.includes('DELETED'));
+    test.strictEqual(result.size, 2048);
+    test.done();
+};
+
+module.exports['Commands: status requests DELETED with QUOTA=RES-MESSAGE on rev1 sessions'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        // RFC 9208: the DELETED status item is mandatory when QUOTA=RES-MESSAGE
+        // is advertised, even without IMAP4rev2
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['QUOTA=RES-MESSAGE', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'DELETED' }, { value: '4' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { deleted: true });
+    test.ok(queryAttrs.includes('DELETED'));
+    test.strictEqual(result.deleted, 4);
+    test.done();
+};
+
+module.exports['Commands: status drops SIZE and DELETED on rev1 sessions without support'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'MESSAGES' }, { value: '100' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    // requesting them must not poison the whole STATUS command on a server that
+    // does not know these items
+    const result = await statusCommand(connection, 'INBOX', { messages: true, size: true, deleted: true });
+    test.ok(!queryAttrs.includes('SIZE'));
+    test.ok(!queryAttrs.includes('DELETED'));
+    test.equal(result.messages, 100);
+    test.done();
+};
+
 module.exports['Commands: status skips when all query values are false'] = async test => {
     const connection = createMockConnection({ state: 2 });
 
@@ -7007,10 +7328,14 @@ module.exports['Commands: idle NOOP fallback uses STATUS when configured'] = asy
 };
 
 module.exports['Commands: idle NOOP fallback uses SELECT when configured'] = async test => {
+    // SELECT polling goes through the real select implementation, so it applies the same
+    // mailbox state transitions as a caller-issued select instead of replaying wire arguments.
     let selectCalled = false;
     const connection = createMockConnection({
         state: 3,
         capabilities: new Map(),
+        // The mailbox is already open, so its folder metadata is cached (no LIST round trip)
+        folders: new Map([['INBOX', { path: 'INBOX', delimiter: '/' }]]),
         currentSelectCommand: { command: 'SELECT', arguments: [{ value: 'INBOX' }] },
         missingIdleCommand: 'SELECT',
         exec: async cmd => {
@@ -7020,12 +7345,14 @@ module.exports['Commands: idle NOOP fallback uses SELECT when configured'] = asy
                     await connection.preCheck();
                 }
             }
-            return { next: () => {} };
+            return { next: () => {}, response: { attributes: [{ value: 'OK' }] } };
         }
     });
 
     await idleCommand(connection);
     test.equal(selectCalled, true);
+    test.equal(connection.mailbox.path, 'INBOX', 'mailbox state was reapplied by the select implementation');
+    test.equal(connection.mailbox.delimiter, '/', 'cached folder metadata was merged in, as with a normal SELECT');
     test.done();
 };
 
@@ -7591,6 +7918,30 @@ module.exports['Commands: namespace with NAMESPACE capability'] = async test =>
     test.done();
 };
 
+module.exports['Commands: namespace uses the real command on rev2-only servers without the token'] = async test => {
+    const connection = createMockConnection({
+        state: 2,
+        // NAMESPACE is folded into base IMAP4rev2 (RFC 9051 Appendix E) - a
+        // rev2-only server gets a real NAMESPACE command, not the LIST fallback
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, args, opts) => {
+            test.equal(cmd, 'NAMESPACE');
+            if (opts && opts.untagged && opts.untagged.NAMESPACE) {
+                await opts.untagged.NAMESPACE({
+                    attributes: [[[{ value: '' }, { value: '/' }]], null, null]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await namespaceCommand(connection);
+    test.ok(result);
+    test.equal(result.prefix, '');
+    test.equal(result.delimiter, '/');
+    test.done();
+};
+
 module.exports['Commands: namespace fallback without capability'] = async test => {
     const connection = createMockConnection({
         state: 2, // AUTHENTICATED

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

@@ -608,46 +608,10 @@ module.exports['Connection Edge: Race condition in mailbox lock'] = test => {
     });
 };
 
-module.exports['Connection Edge: Capability update after STARTTLS'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        port: 143,
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    // Mock capabilities
-    client.capabilities = new Map();
-    client.capabilities.set('STARTTLS', true);
-
-    // Mock run method
-    client.run = async command => {
-        if (command === 'STARTTLS') {
-            client.expectCapabilityUpdate = true;
-            return true;
-        }
-        if (command === 'CAPABILITY') {
-            return true;
-        }
-    };
-
-    // Mock socket upgrade
-    client.socket = new EventEmitter();
-    client.socket.unpipe = () => {};
-    client.streamer = new EventEmitter();
-
-    // Override the upgradeToSTARTTLS to test capability update
-    client
-        .upgradeToSTARTTLS()
-        .then(result => {
-            test.ok(result, 'Should successfully upgrade to TLS');
-            test.ok(client.expectCapabilityUpdate, 'Should expect capability update');
-            test.done();
-        })
-        .catch(() => {
-            // Expected for this mock setup
-            test.done();
-        });
-};
+// NB! the capability discard/re-fetch behavior around STARTTLS is asserted end to
+// end in imap-flow-secure-test.js ('Secure: STARTTLS upgrade completes a session',
+// PRETLS-ONLY/POSTTLS-ONLY markers) - a mocked upgradeToSTARTTLS cannot reach the
+// re-fetch code without a real TLS handshake, so no vacuous variant is kept here.
 
 module.exports['Connection Edge: Event handlers attached before piping'] = test => {
     let client = new ImapFlow({