imapflow 1.7.7 → 2.0.0

package/test/imap-flow-methods-test.js

@@ -1,889 +0,0 @@
-'use strict';
-
-// Unit tests that exercise ImapFlow public/command methods against a real
-// ImapFlow instance with `run` (and occasionally lower-level helpers) stubbed.
-// This deterministically covers the thin command wrappers, range resolution,
-// the untagged response handlers, and the fetch/download orchestration without
-// requiring a live IMAP server.
-
-const { ImapFlow } = require('../lib/imap-flow');
-
-// Build a real ImapFlow instance with logging disabled and a selected mailbox.
-// `run` is stubbed by default to record calls and return a configurable value.
-const makeClient = (overrides = {}) => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        port: 993,
-        auth: { user: 'test', pass: 'test' },
-        logger: false,
-        ...overrides
-    });
-    client.socket = { destroyed: false, destroy: () => {} };
-    client.usable = true;
-    client.mailbox = {
-        path: 'INBOX',
-        exists: 10,
-        flags: new Set(['\\Seen', '\\Flagged']),
-        permanentFlags: new Set(['\\*'])
-    };
-    client.state = client.states.SELECTED;
-    return client;
-};
-
-// Records every run() invocation so assertions can verify the dispatched command.
-const recordRun = (client, returnValue) => {
-    let calls = [];
-    client.run = async (...args) => {
-        calls.push(args);
-        return typeof returnValue === 'function' ? returnValue(...args) : returnValue;
-    };
-    return calls;
-};
-
-// ============================================================================
-// Thin command wrappers
-// ============================================================================
-
-module.exports['Methods: getQuota defaults path to INBOX'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'INBOX' });
-    let res = await client.getQuota();
-    test.deepEqual(calls[0], ['QUOTA', 'INBOX']);
-    test.deepEqual(res, { path: 'INBOX' });
-    test.done();
-};
-
-module.exports['Methods: getQuota uses given path'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, false);
-    await client.getQuota('Archive');
-    test.deepEqual(calls[0], ['QUOTA', 'Archive']);
-    test.done();
-};
-
-module.exports['Methods: list builds folders map'] = async test => {
-    let client = makeClient();
-    recordRun(client, [
-        { path: 'INBOX', name: 'INBOX' },
-        { path: 'Sent', name: 'Sent' }
-    ]);
-    let folders = await client.list();
-    test.equal(folders.length, 2);
-    test.ok(client.folders instanceof Map);
-    test.equal(client.folders.get('Sent').name, 'Sent');
-    test.done();
-};
-
-module.exports['Methods: list passes options'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, []);
-    await client.list({ statusQuery: { messages: true } });
-    test.deepEqual(calls[0][0], 'LIST');
-    test.deepEqual(calls[0][3], { statusQuery: { messages: true } });
-    test.done();
-};
-
-module.exports['Methods: listTree returns tree structure'] = async test => {
-    let client = makeClient();
-    recordRun(client, [
-        { path: 'INBOX', name: 'INBOX', delimiter: '/', parent: [], flags: new Set() },
-        { path: 'INBOX/Sub', name: 'Sub', delimiter: '/', parent: ['INBOX'], flags: new Set() }
-    ]);
-    let tree = await client.listTree();
-    test.ok(tree);
-    test.ok(Array.isArray(tree.folders));
-    test.ok(client.folders instanceof Map);
-    test.done();
-};
-
-module.exports['Methods: listTree passes through inline status objects'] = async test => {
-    let client = makeClient();
-    recordRun(client, [
-        { path: 'INBOX', name: 'INBOX', delimiter: '/', parent: [], flags: new Set(), status: { path: 'INBOX', messages: 5, unseen: 2 } },
-        { path: 'INBOX/Sub', name: 'Sub', delimiter: '/', parent: ['INBOX'], flags: new Set() }
-    ]);
-    let tree = await client.listTree({ statusQuery: { messages: true, unseen: true } });
-    // The StatusObject must survive into the tree node - it used to be coerced
-    // into a boolean by the tree builder
-    test.deepEqual(tree.folders[0].status, { path: 'INBOX', messages: 5, unseen: 2 });
-    test.done();
-};
-
-module.exports['Methods: noop dispatches NOOP'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.noop();
-    test.deepEqual(calls[0], ['NOOP']);
-    test.done();
-};
-
-module.exports['Methods: mailboxCreate dispatches CREATE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'New', created: true });
-    let res = await client.mailboxCreate(['parent', 'child']);
-    test.deepEqual(calls[0], ['CREATE', ['parent', 'child']]);
-    test.equal(res.created, true);
-    test.done();
-};
-
-module.exports['Methods: mailboxRename dispatches RENAME'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'a', newPath: 'b' });
-    await client.mailboxRename('a', 'b');
-    test.deepEqual(calls[0], ['RENAME', 'a', 'b']);
-    test.done();
-};
-
-module.exports['Methods: mailboxDelete dispatches DELETE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'a' });
-    await client.mailboxDelete('a');
-    test.deepEqual(calls[0], ['DELETE', 'a']);
-    test.done();
-};
-
-module.exports['Methods: mailboxSubscribe dispatches SUBSCRIBE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.mailboxSubscribe('a');
-    test.deepEqual(calls[0], ['SUBSCRIBE', 'a']);
-    test.done();
-};
-
-module.exports['Methods: mailboxUnsubscribe dispatches UNSUBSCRIBE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.mailboxUnsubscribe('a');
-    test.deepEqual(calls[0], ['UNSUBSCRIBE', 'a']);
-    test.done();
-};
-
-module.exports['Methods: mailboxOpen dispatches SELECT'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'INBOX' });
-    await client.mailboxOpen('INBOX', { readOnly: true });
-    test.deepEqual(calls[0], ['SELECT', 'INBOX', { readOnly: true }]);
-    test.done();
-};
-
-module.exports['Methods: mailboxClose dispatches CLOSE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.mailboxClose();
-    test.deepEqual(calls[0], ['CLOSE']);
-    test.done();
-};
-
-module.exports['Methods: status dispatches STATUS'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'INBOX', unseen: 3 });
-    let res = await client.status('INBOX', { unseen: true });
-    test.deepEqual(calls[0], ['STATUS', 'INBOX', { unseen: true }]);
-    test.equal(res.unseen, 3);
-    test.done();
-};
-
-// ============================================================================
-// idle()
-// ============================================================================
-
-module.exports['Methods: idle runs IDLE when not already idling'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.idle();
-    test.deepEqual(calls[0], ['IDLE', client.maxIdleTime]);
-    test.done();
-};
-
-module.exports['Methods: idle is a no-op when already idling'] = async test => {
-    let client = makeClient();
-    client.idling = true;
-    let calls = recordRun(client, true);
-    let res = await client.idle();
-    test.equal(calls.length, 0);
-    test.equal(res, undefined);
-    test.done();
-};
-
-// ============================================================================
-// Flag operations + range resolution
-// ============================================================================
-
-module.exports['Methods: messageFlagsSet resolves range and dispatches STORE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    let res = await client.messageFlagsSet('1:5', ['\\Seen'], { uid: true });
-    test.equal(res, true);
-    test.equal(calls[0][0], 'STORE');
-    test.equal(calls[0][1], '1:5');
-    test.deepEqual(calls[0][3], { operation: 'set', uid: true });
-    test.done();
-};
-
-module.exports['Methods: messageFlagsSet works without an options argument'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    let res = await client.messageFlagsSet('1', ['\\Seen']); // no options -> options || {}
-    test.equal(res, true);
-    test.equal(calls[0][0], 'STORE');
-    test.done();
-};
-
-module.exports['Methods: search derivation handles non-string returnOptions entries'] = async test => {
-    let client = makeClient();
-    recordRun(client, [1, 2, 3]); // no ESEARCH -> client-side derivation runs
-    // a non-string returnOption (object) is passed through untouched by the mapper
-    let res = await client.search({ all: true }, { returnOptions: ['count', { partial: '1:2' }] });
-    test.equal(res.count, 3);
-    test.done();
-};
-
-module.exports['Methods: messageFlagsSet returns false for empty range'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    let res = await client.messageFlagsSet([], ['\\Seen'], {});
-    test.equal(res, false);
-    test.equal(calls.length, 0);
-    test.done();
-};
-
-module.exports['Methods: messageFlagsAdd dispatches STORE add'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.messageFlagsAdd('1', ['\\Flagged']);
-    test.equal(calls[0][3].operation, 'add');
-    test.done();
-};
-
-module.exports['Methods: messageFlagsAdd returns false on empty range'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.messageFlagsAdd([], ['\\Flagged']);
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: messageFlagsRemove dispatches STORE remove'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    await client.messageFlagsRemove('1', ['\\Flagged']);
-    test.equal(calls[0][3].operation, 'remove');
-    test.done();
-};
-
-module.exports['Methods: messageFlagsRemove returns false on empty range'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.messageFlagsRemove([], ['\\Flagged']);
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: setFlagColor returns false for empty range'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.setFlagColor([], 'red');
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: setFlagColor returns false for invalid color'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.setFlagColor('1', 'not-a-color');
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: setFlagColor red issues add and remove STORE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    // red sets \\Flagged and clears the MailFlagBit* keywords -> both add and remove
-    let res = await client.setFlagColor('1:*', 'red');
-    test.ok(res);
-    let ops = calls.map(c => c[3].operation);
-    test.ok(ops.includes('add'));
-    test.ok(ops.includes('remove'));
-    test.done();
-};
-
-module.exports['Methods: setFlagColor removal (null color) issues only a remove STORE'] = async test => {
-    test.expect(5);
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    // A null/empty color clears the color: getColorFlags returns an empty add set and a
-    // non-empty remove set, so the add STORE is skipped and only the remove STORE runs.
-    let res = await client.setFlagColor('1', null);
-    test.ok(res);
-    test.equal(calls.length, 1);
-    test.equal(calls[0][0], 'STORE');
-    test.equal(calls[0][3].operation, 'remove');
-    test.deepEqual(calls[0][2], ['\\Flagged', '$MailFlagBit0', '$MailFlagBit1', '$MailFlagBit2']);
-    test.done();
-};
-
-module.exports['Methods: messageDelete resolves range and dispatches EXPUNGE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, true);
-    let res = await client.messageDelete('1:3', { uid: true });
-    test.equal(res, true);
-    test.equal(calls[0][0], 'EXPUNGE');
-    test.equal(calls[0][1], '1:3');
-    test.done();
-};
-
-module.exports['Methods: messageDelete returns false on empty range'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.messageDelete([]);
-    test.equal(res, false);
-    test.done();
-};
-
-// ============================================================================
-// append / copy / move
-// ============================================================================
-
-module.exports['Methods: append dispatches APPEND'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { destination: 'INBOX', uid: 5 });
-    let res = await client.append('INBOX', 'raw message', ['\\Seen'], new Date(2020, 1, 1));
-    test.equal(calls[0][0], 'APPEND');
-    test.equal(res.uid, 5);
-    test.done();
-};
-
-module.exports['Methods: append returns false when run returns falsy'] = async test => {
-    let client = makeClient();
-    recordRun(client, false);
-    let res = await client.append('INBOX', 'raw');
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: messageCopy resolves range and dispatches COPY'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { destination: 'Backup' });
-    await client.messageCopy('1:*', 'Backup', { uid: false });
-    test.equal(calls[0][0], 'COPY');
-    test.equal(calls[0][2], 'Backup');
-    test.done();
-};
-
-module.exports['Methods: messageCopy returns false on empty range'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.messageCopy([], 'Backup');
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: messageMove resolves range and dispatches MOVE'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { destination: 'Trash' });
-    await client.messageMove('1', 'Trash');
-    test.equal(calls[0][0], 'MOVE');
-    test.equal(calls[0][2], 'Trash');
-    test.done();
-};
-
-module.exports['Methods: messageMove returns false on empty range'] = async test => {
-    let client = makeClient();
-    recordRun(client, true);
-    let res = await client.messageMove([], 'Trash');
-    test.equal(res, false);
-    test.done();
-};
-
-// ============================================================================
-// resolveRange branches
-// ============================================================================
-
-module.exports['Methods: resolveRange converts number'] = async test => {
-    let client = makeClient();
-    let res = await client.resolveRange(5, {});
-    test.equal(res, '5');
-    test.done();
-};
-
-module.exports['Methods: resolveRange converts bigint'] = async test => {
-    let client = makeClient();
-    let res = await client.resolveRange(BigInt(7), {});
-    test.equal(res, '7');
-    test.done();
-};
-
-module.exports['Methods: resolveRange star uses mailbox.exists'] = async test => {
-    let client = makeClient();
-    let options = {};
-    let res = await client.resolveRange('*', options);
-    test.equal(res, '10');
-    test.equal(options.uid, false);
-    test.done();
-};
-
-module.exports['Methods: resolveRange star returns false on empty mailbox'] = async test => {
-    let client = makeClient();
-    client.mailbox.exists = 0;
-    let res = await client.resolveRange('*', {});
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: resolveRange all:true => 1:*'] = async test => {
-    let client = makeClient();
-    let res = await client.resolveRange({ all: true }, {});
-    test.equal(res, '1:*');
-    test.done();
-};
-
-module.exports['Methods: resolveRange uid object'] = async test => {
-    let client = makeClient();
-    let options = {};
-    let res = await client.resolveRange({ uid: '100:200' }, options);
-    test.equal(res, '100:200');
-    test.equal(options.uid, true);
-    test.done();
-};
-
-module.exports['Methods: resolveRange search query runs SEARCH and packs'] = async test => {
-    let client = makeClient();
-    let options = {};
-    client.run = async (cmd, query, opts) => {
-        test.equal(cmd, 'SEARCH');
-        test.equal(opts.uid, true);
-        return [1, 2, 3, 5];
-    };
-    let res = await client.resolveRange({ seen: false }, options);
-    test.equal(res, '1:3,5');
-    test.done();
-};
-
-module.exports['Methods: resolveRange search query with no hits'] = async test => {
-    let client = makeClient();
-    client.run = async () => [];
-    let res = await client.resolveRange({ seen: false }, {});
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: resolveRange array joins with commas'] = async test => {
-    let client = makeClient();
-    let res = await client.resolveRange([1, 2, 4], {});
-    test.equal(res, '1,2,4');
-    test.done();
-};
-
-module.exports['Methods: resolveRange empty string returns false'] = async test => {
-    let client = makeClient();
-    let res = await client.resolveRange('', {});
-    test.equal(res, false);
-    test.done();
-};
-
-// ============================================================================
-// ensureSelectedMailbox
-// ============================================================================
-
-module.exports['Methods: ensureSelectedMailbox returns false without path'] = async test => {
-    let client = makeClient();
-    let res = await client.ensureSelectedMailbox(null);
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: ensureSelectedMailbox returns true when already selected'] = async test => {
-    let client = makeClient();
-    let res = await client.ensureSelectedMailbox('INBOX');
-    test.equal(res, true);
-    test.done();
-};
-
-module.exports['Methods: ensureSelectedMailbox opens a different mailbox'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, { path: 'Other' });
-    await client.ensureSelectedMailbox('Other');
-    test.equal(calls[0][0], 'SELECT');
-    test.equal(calls[0][1], 'Other');
-    test.done();
-};
-
-// ============================================================================
-// search()
-// ============================================================================
-
-module.exports['Methods: search returns undefined without mailbox'] = async test => {
-    let client = makeClient();
-    client.mailbox = false;
-    let res = await client.search({ seen: false });
-    test.equal(res, undefined);
-    test.done();
-};
-
-module.exports['Methods: search returns server result'] = async test => {
-    let client = makeClient();
-    recordRun(client, [1, 2, 3]);
-    let res = await client.search({ seen: false });
-    test.deepEqual(res, [1, 2, 3]);
-    test.done();
-};
-
-module.exports['Methods: search returns false when run returns falsy'] = async test => {
-    let client = makeClient();
-    recordRun(client, null);
-    let res = await client.search({ all: true });
-    test.equal(res, false);
-    test.done();
-};
-
-module.exports['Methods: search derives ESearch COUNT/MIN/MAX/ALL client-side'] = async test => {
-    let client = makeClient();
-    recordRun(client, [2, 4, 6, 8]);
-    let res = await client.search({ all: true }, { returnOptions: ['count', 'min', 'max', 'all'] });
-    test.equal(res.count, 4);
-    test.equal(res.min, 2);
-    test.equal(res.max, 8);
-    test.equal(res.all, '2,4,6,8');
-    test.done();
-};
-
-module.exports['Methods: search returnOptions PARTIAL only returns raw array'] = async test => {
-    let client = makeClient();
-    recordRun(client, [1, 2, 3]);
-    let res = await client.search({ all: true }, { returnOptions: ['partial'] });
-    test.deepEqual(res, [1, 2, 3]);
-    test.done();
-};
-
-// ============================================================================
-// Untagged response handlers
-// ============================================================================
-
-module.exports['Methods: untaggedExists ignores when no mailbox'] = async test => {
-    let client = makeClient();
-    client.mailbox = false;
-    await client.untaggedExists({ command: '12' });
-    test.ok(true);
-    test.done();
-};
-
-module.exports['Methods: untaggedExists ignores invalid command'] = async test => {
-    let client = makeClient();
-    let fired = false;
-    client.on('exists', () => {
-        fired = true;
-    });
-    await client.untaggedExists({ command: 'NaNvalue' });
-    test.equal(fired, false);
-    test.done();
-};
-
-module.exports['Methods: untaggedExists no-op when count unchanged'] = async test => {
-    let client = makeClient();
-    client.mailbox.exists = 10;
-    let fired = false;
-    client.on('exists', () => {
-        fired = true;
-    });
-    await client.untaggedExists({ command: '10' });
-    test.equal(fired, false);
-    test.done();
-};
-
-module.exports['Methods: untaggedExists emits exists event on change'] = async test => {
-    let client = makeClient();
-    client.mailbox.exists = 10;
-    let evt = null;
-    client.on('exists', e => {
-        evt = e;
-    });
-    await client.untaggedExists({ command: '12' });
-    test.ok(evt);
-    test.equal(evt.count, 12);
-    test.equal(evt.prevCount, 10);
-    test.equal(client.mailbox.exists, 12);
-    test.done();
-};
-
-module.exports['Methods: untaggedExpunge ignores when no mailbox'] = async test => {
-    let client = makeClient();
-    client.mailbox = false;
-    await client.untaggedExpunge({ command: '2' });
-    test.ok(true);
-    test.done();
-};
-
-module.exports['Methods: untaggedExpunge ignores invalid command'] = async test => {
-    let client = makeClient();
-    let fired = false;
-    client.on('expunge', () => {
-        fired = true;
-    });
-    await client.untaggedExpunge({ command: 'x' });
-    test.equal(fired, false);
-    test.done();
-};
-
-module.exports['Methods: untaggedExpunge emits expunge event'] = async test => {
-    let client = makeClient();
-    client.mailbox.exists = 10;
-    let evt = null;
-    client.on('expunge', e => {
-        evt = e;
-    });
-    await client.untaggedExpunge({ command: '3' });
-    test.ok(evt);
-    test.equal(evt.seq, 3);
-    test.equal(evt.vanished, false);
-    test.equal(client.mailbox.exists, 9);
-    test.done();
-};
-
-module.exports['Methods: untaggedExpunge uses expungeHandler when set'] = async test => {
-    let payloads = [];
-    let client = makeClient({ expungeHandler: async payload => payloads.push(payload) });
-    client.mailbox.exists = 5;
-    await client.untaggedExpunge({ command: '2' });
-    test.equal(payloads.length, 1);
-    test.equal(payloads[0].seq, 2);
-    test.done();
-};
-
-module.exports['Methods: untaggedExpunge handles expungeHandler error'] = async test => {
-    let client = makeClient({
-        expungeHandler: async () => {
-            throw new Error('handler boom');
-        }
-    });
-    client.mailbox.exists = 5;
-    // Should not throw despite handler error
-    await client.untaggedExpunge({ command: '2' });
-    test.ok(true);
-    test.done();
-};
-
-module.exports['Methods: untaggedVanished ignores when no mailbox'] = async test => {
-    let client = makeClient();
-    client.mailbox = false;
-    await client.untaggedVanished({ attributes: [{ value: '1:3' }] });
-    test.ok(true);
-    test.done();
-};
-
-module.exports['Methods: untaggedVanished emits expunge per uid'] = async test => {
-    let client = makeClient();
-    let events = [];
-    client.on('expunge', e => events.push(e));
-    await client.untaggedVanished({ attributes: [{ value: '1:3' }] });
-    test.equal(events.length, 3);
-    test.equal(events[0].uid, 1);
-    test.equal(events[0].vanished, true);
-    test.equal(events[0].earlier, false);
-    test.done();
-};
-
-module.exports['Methods: untaggedVanished EARLIER tag sets earlier flag'] = async test => {
-    let client = makeClient();
-    let events = [];
-    client.on('expunge', e => events.push(e));
-    await client.untaggedVanished({
-        attributes: [[{ value: 'EARLIER' }], { value: '5' }]
-    });
-    test.equal(events.length, 1);
-    test.equal(events[0].uid, 5);
-    test.equal(events[0].earlier, true);
-    test.done();
-};
-
-module.exports['Methods: untaggedVanished routes through expungeHandler'] = async test => {
-    let payloads = [];
-    let client = makeClient({ expungeHandler: async p => payloads.push(p) });
-    await client.untaggedVanished({ attributes: [{ value: '7' }] });
-    test.equal(payloads.length, 1);
-    test.equal(payloads[0].uid, 7);
-    test.done();
-};
-
-module.exports['Methods: untaggedVanished swallows expungeHandler error'] = async test => {
-    let client = makeClient({
-        expungeHandler: async () => {
-            throw new Error('vanished boom');
-        }
-    });
-    await client.untaggedVanished({ attributes: [{ value: '7' }] });
-    test.ok(true);
-    test.done();
-};
-
-module.exports['Methods: untaggedFetch ignores when no mailbox'] = async test => {
-    let client = makeClient();
-    client.mailbox = false;
-    await client.untaggedFetch({ command: '1', attributes: [] });
-    test.ok(true);
-    test.done();
-};
-
-module.exports['Methods: untaggedFetch emits flags event'] = async test => {
-    let client = makeClient();
-    let evt = null;
-    client.on('flags', e => {
-        evt = e;
-    });
-    // Build an untagged FETCH with FLAGS and UID attributes
-    let untagged = {
-        command: '1',
-        attributes: [
-            { type: 'ATOM', value: 'FETCH' },
-            [{ type: 'ATOM', value: 'UID' }, { type: 'ATOM', value: '100' }, { type: 'ATOM', value: 'FLAGS' }, [{ type: 'ATOM', value: '\\Seen' }]]
-        ]
-    };
-    await client.untaggedFetch(untagged);
-    test.ok(evt);
-    test.equal(evt.uid, 100);
-    test.ok(evt.flags instanceof Set);
-    test.ok(evt.flags.has('\\Seen'));
-    test.done();
-};
-
-// ============================================
-// autoEnable
-// ============================================
-
-module.exports['Methods: autoEnable requests IMAP4rev2 alongside the base extensions'] = async test => {
-    let client = makeClient();
-    let calls = recordRun(client, new Set(['CONDSTORE', 'IMAP4REV2']));
-    await client.autoEnable();
-    test.equal(calls.length, 1);
-    test.deepEqual(calls[0], ['ENABLE', ['CONDSTORE', 'UTF8=ACCEPT', 'IMAP4rev2']]);
-    test.done();
-};
-
-module.exports['Methods: autoEnable honors disableIMAP4rev2'] = async test => {
-    let client = makeClient({ disableIMAP4rev2: true });
-    let calls = recordRun(client, new Set(['CONDSTORE']));
-    await client.autoEnable();
-    test.equal(calls.length, 1);
-    test.deepEqual(calls[0], ['ENABLE', ['CONDSTORE', 'UTF8=ACCEPT']]);
-    test.done();
-};
-
-module.exports['Methods: autoEnable includes QRESYNC when requested'] = async test => {
-    let client = makeClient({ qresync: true });
-    let calls = recordRun(client, new Set(['CONDSTORE', 'QRESYNC', 'IMAP4REV2']));
-    await client.autoEnable();
-    test.equal(calls.length, 1);
-    test.deepEqual(calls[0], ['ENABLE', ['CONDSTORE', 'UTF8=ACCEPT', 'QRESYNC', 'IMAP4rev2']]);
-    test.done();
-};
-
-module.exports['Methods: autoEnable retries without IMAP4rev2 when the whole command fails'] = async test => {
-    let client = makeClient();
-    // RFC 5161 requires unknown ENABLE arguments to be ignored, but a broken
-    // server may reject the whole command over IMAP4rev2 - the retry keeps
-    // CONDSTORE/UTF8=ACCEPT from being lost as collateral damage
-    let calls = recordRun(client, (cmd, list) => (list.includes('IMAP4rev2') ? false : new Set(['CONDSTORE'])));
-    await client.autoEnable();
-    test.equal(calls.length, 2);
-    test.deepEqual(calls[1], ['ENABLE', ['CONDSTORE', 'UTF8=ACCEPT']]);
-    test.done();
-};
-
-module.exports['Methods: autoEnable does not retry when disableIMAP4rev2 already omitted it'] = async test => {
-    let client = makeClient({ disableIMAP4rev2: true });
-    let calls = recordRun(client, () => false);
-    await client.autoEnable();
-    test.equal(calls.length, 1);
-    test.done();
-};
-
-module.exports['Methods: untaggedExpunge refuses an unusable sequence number'] = async test => {
-    // Same bound untaggedExists() applies: an overflowing or non-decimal value must not
-    // decrement the live message count
-    let client = makeClient();
-    client.mailbox.exists = 10;
-    let events = [];
-    client.on('expunge', e => events.push(e));
-
-    await client.untaggedExpunge(false);
-    for (let bad of ['9'.repeat(400), '1e5', '0', 'abc', '']) {
-        await client.untaggedExpunge({ command: bad });
-    }
-    test.equal(client.mailbox.exists, 10, 'the live message count must be left alone');
-    test.equal(events.length, 0);
-
-    await client.untaggedExpunge({ command: '3' });
-    test.equal(client.mailbox.exists, 9, 'a usable sequence number is still applied');
-    test.equal(events.length, 1);
-    test.equal(events[0].seq, 3);
-    test.done();
-};
-
-module.exports['Methods: untaggedVanished survives a malformed response'] = async test => {
-    // "* VANISHED (EARLIER)" leaves no sequence set at all. Throwing here would abort the
-    // handler for the whole response, and handleResponse only warns - so every expunge the
-    // response did carry would be dropped and the client's mailbox view would go stale.
-    let client = makeClient();
-    let events = [];
-    client.on('expunge', e => events.push(e));
-
-    await client.untaggedVanished({ attributes: [[{ value: 'EARLIER' }]] });
-    await client.untaggedVanished({ attributes: [] });
-    await client.untaggedVanished({});
-    await client.untaggedVanished({ attributes: [[{ value: 'EARLIER' }], null] });
-
-    test.equal(events.length, 0, 'nothing to report, and nothing thrown');
-
-    // a well-formed response still works after the malformed ones
-    await client.untaggedVanished({ attributes: [[{ value: 'EARLIER' }], { value: '5:6' }] });
-    test.equal(events.length, 2);
-    test.equal(events[0].uid, 5);
-    test.equal(events[0].earlier, true);
-    test.done();
-};
-
-module.exports['Methods: untaggedExists refuses an overflowing count'] = async test => {
-    // Number('9'.repeat(400)) is Infinity: resolveRange('*') would then compile the literal
-    // string "Infinity" and every range-based command would fail until the next SELECT
-    let client = makeClient();
-    client.mailbox = { path: 'INBOX', exists: 5 };
-    let events = [];
-    client.on('exists', e => events.push(e));
-
-    await client.untaggedExists(false);
-    await client.untaggedExists({});
-    for (let bad of ['9'.repeat(400), '1e5', '-1', 'abc', '1.5', '']) {
-        await client.untaggedExists({ command: bad });
-    }
-    test.equal(client.mailbox.exists, 5, 'the live message count must be left alone');
-    test.equal(events.length, 0);
-
-    await client.untaggedExists({ command: '7' });
-    test.equal(client.mailbox.exists, 7, 'a usable count is still applied');
-    test.equal(events.length, 1);
-    test.done();
-};
-
-module.exports['Methods: throttleWait caps the delay and close() aborts it'] = async test => {
-    let client = makeClient();
-
-    // A server hint is unbounded; the wait may never outlive the client either
-    let started = Date.now();
-    let pending = client.throttleWait(7 * 24 * 3600 * 1000);
-    test.equal(client._throttleWaits.size, 1, 'the wait is tracked so close() can reach it');
-
-    client.close();
-    test.equal(await pending, true, 'an aborted wait reports true');
-    test.equal(client._throttleWaits.size, 0, 'the tracked wait is released');
-    test.ok(Date.now() - started < 5000, 'close() must not wait out the delay');
-
-    // normal expiry reports false and releases the entry. The back-off timer is deliberately
-    // unref'd, so the test has to hold the event loop open itself - in a real session the
-    // socket does that.
-    let client2 = makeClient();
-    let keepAlive = setTimeout(() => {}, 1000);
-    test.equal(await client2.throttleWait(1), false);
-    clearTimeout(keepAlive);
-    test.equal(client2._throttleWaits.size, 0);
-    client2.close();
-    test.done();
-};