imapflow 1.6.3 → 1.6.5

package/lib/imap-flow.js

@@ -643,22 +643,40 @@ class ImapFlow extends EventEmitter {
         }
 
         if (typeof options.onSend === 'function') {
-            options.onSend();
+            // The command is already on the wire, so a throwing onSend callback must not
+            // reach trySend()'s catch - that would reject the request and dispatch the
+            // next command into the server's pending state for this one.
+            try {
+                options.onSend();
+            } catch (err) {
+                this.log.warn({ err, cid: this.id });
+            }
         }
     }
 
     async trySend() {
-        if (this.currentRequest || !this.requestQueue.length) {
-            return;
-        }
-        this.currentRequest = this.requestQueue.shift();
+        while (!this.currentRequest && this.requestQueue.length) {
+            this.currentRequest = this.requestQueue.shift();
 
-        await this.send({
-            tag: this.currentRequest.tag,
-            command: this.currentRequest.command,
-            attributes: this.currentRequest.attributes,
-            options: this.currentRequest.options
-        });
+            try {
+                await this.send({
+                    tag: this.currentRequest.tag,
+                    command: this.currentRequest.command,
+                    attributes: this.currentRequest.attributes,
+                    options: this.currentRequest.options
+                });
+                return;
+            } catch (err) {
+                // A failure here (most likely the compiler refusing an invalid
+                // user-supplied value) belongs to the command that was being dispatched.
+                // Without this the shifted request would stay currentRequest forever:
+                // nothing reached the wire, so no tagged response ever clears it, and
+                // every later command would queue behind it until the socket timeout.
+                // Reject the failed command and keep draining the queue.
+                this.commandParts = [];
+                this.rejectCurrentRequest(err);
+            }
+        }
     }
 
     exec(command, attributes, options) {
@@ -685,10 +703,10 @@ class ImapFlow extends EventEmitter {
         let promise = new Promise((resolve, reject) => {
             this.requestTagMap.set(tag, { command, attributes, options, resolve, reject });
             this.requestQueue.push({ tag, command, attributes, options });
-            this.trySend().catch(err => {
-                this.requestTagMap.delete(tag);
-                reject(err);
-            });
+            // trySend() settles dispatch failures itself, by rejecting the affected
+            // command through requestTagMap; this catch exists only so a throw from the
+            // dispatch machinery itself can never surface as a floating rejection.
+            this.trySend().catch(err => this.log.warn({ err, cid: this.id }));
         });
 
         // Prevent unhandled promise rejection if close() rejects this request
@@ -834,6 +852,42 @@ class ImapFlow extends EventEmitter {
         }
     }
 
+    /**
+     * Fails the in-flight command when a line that could not be parsed was addressed to its tag.
+     * Only the leading tag is read from the raw payload - the rest of the line is by definition
+     * not trustworthy - and only the command that is actually on the wire may be settled this way,
+     * the same invariant the parsed tagged-response path enforces.
+     *
+     * @param {Buffer} payload - Raw bytes of the line that failed to parse.
+     * @param {Error} parserError - The error the parser raised.
+     */
+    rejectUnparsedCompletion(payload, parserError) {
+        if (!this.currentRequest || !this.currentRequest.sent) {
+            return;
+        }
+
+        // Prefer the tag the parser had already extracted before it failed - it went
+        // through the same leading-NUL workaround as every parsed response. Fall back
+        // to the raw bytes for lines whose tag itself was unparseable: skip the NUL
+        // padding buggy servers prepend and stop at the first byte a tag cannot contain.
+        let tag = parserError && parserError.parsedTag;
+        if (!tag) {
+            // eslint-disable-next-line no-control-regex
+            let match = payload.toString('latin1', 0, 64).match(/^\0*([^\s\x00-\x1f\x7f]+)/);
+            tag = match && match[1];
+        }
+        if (!tag || tag !== this.currentRequest.tag) {
+            return;
+        }
+
+        let err = new Error('Failed to parse the server response for this command');
+        err.code = parserError.code || 'ParserError';
+        err.parserError = parserError;
+        this.rejectCurrentRequest(err);
+
+        this.trySend().catch(sendErr => this.log.warn({ err: sendErr, cid: this.id }));
+    }
+
     /**
      * Handles a single parsed server response: telemetry, continuation requests, response-code
      * section handlers, untagged handlers and tagged command completion.
@@ -846,26 +900,42 @@ class ImapFlow extends EventEmitter {
 
         try {
             parsed = await parser(data.payload, { literals: data.literals });
-            if (parsed.tag && !['*', '+'].includes(parsed.tag) && parsed.command) {
-                let payload = { response: parsed.command };
-
-                if (
-                    parsed.attributes &&
-                    parsed.attributes[0] &&
-                    parsed.attributes[0].section &&
-                    parsed.attributes[0].section[0] &&
-                    parsed.attributes[0].section[0].type === 'ATOM'
-                ) {
-                    payload.code = parsed.attributes[0].section[0].value;
-                }
-                this.emit('response', payload);
-            }
         } catch (err) {
             // can not make sense of this
             this.log.error({ src: 's', msg: data.payload.toString(), err, cid: this.id });
+            // An unparseable untagged line is junk that can be skipped, but the line may
+            // have been the in-flight command's tagged completion. Dropping that one
+            // silently strands the command: currentRequest is never cleared, so trySend()
+            // stops dispatching and every later command queues behind it until the socket
+            // timeout fires. The tag is recovered from the raw bytes (a tag is
+            // ASTRING-CHAR only, so it survives whatever made the rest unparseable) and
+            // the command is failed with the parser error instead of hanging.
+            this.rejectUnparsedCompletion(data.payload, err);
             return true;
         }
 
+        if (parsed.tag && !['*', '+'].includes(parsed.tag) && parsed.command) {
+            let payload = { response: parsed.command };
+
+            if (
+                parsed.attributes &&
+                parsed.attributes[0] &&
+                parsed.attributes[0].section &&
+                parsed.attributes[0].section[0] &&
+                parsed.attributes[0].section[0].type === 'ATOM'
+            ) {
+                payload.code = parsed.attributes[0].section[0].value;
+            }
+            // Outside the parse try/catch on purpose: a throwing user 'response' listener
+            // is not a parse failure and must not settle the in-flight command or fail the
+            // connection - the same contract untagged handlers get.
+            try {
+                this.emit('response', payload);
+            } catch (err) {
+                this.log.warn({ err, cid: this.id });
+            }
+        }
+
         let logCompiled = await compiler(parsed, {
             isLogging: true
         });
@@ -1629,13 +1699,15 @@ class ImapFlow extends EventEmitter {
             this.writeSocket = this.socket;
         });
 
-        if (upgraded && this.expectCapabilityUpdate) {
-            // After STARTTLS the server may advertise a different capability set
-            // (e.g., LOGINDISABLED removed, new AUTH= methods). Clear the pre-TLS
-            // map before re-fetching so stale capabilities cannot leak through
-            // if the CAPABILITY response is delayed or absent.
-            this.capabilities.clear();
-            this.authCapabilities.clear();
+        if (upgraded) {
+            // RFC 9051 section 6.2.1: once TLS is started the client MUST discard the
+            // cached capabilities and reissue CAPABILITY, because everything learned
+            // before the handshake was plaintext an active attacker could rewrite.
+            // Unconditional on purpose: a server that stamps [CAPABILITY ...] on the
+            // STARTTLS OK itself clears expectCapabilityUpdate, so keying the discard
+            // on that flag would keep exactly the pre-TLS list an attacker controls -
+            // the list that then picks the AUTH mechanism and answers LOGINDISABLED.
+            this.clearCapabilities();
             await this.run('CAPABILITY');
         }
 
@@ -1780,6 +1852,17 @@ class ImapFlow extends EventEmitter {
         this.state = this.states.LOGOUT;
     }
 
+    // Drops every capability-derived field together - the counterpart of
+    // updateCapabilitiesFromRaw() below, which sets them together. rawCapabilities is
+    // public surface external consumers read, so a discard (RFC 9051 6.2.1 requires
+    // one after STARTTLS) that missed it would leave the stale list visible if the
+    // re-fetch fails.
+    clearCapabilities() {
+        this.capabilities.clear();
+        this.authCapabilities.clear();
+        this.rawCapabilities = null;
+    }
+
     updateCapabilitiesFromRaw(rawCapabilities) {
         this.rawCapabilities = rawCapabilities;
         this.capabilities = updateCapabilities(rawCapabilities);

package/lib/search-compiler.js

@@ -30,6 +30,17 @@ let setBoolOpt = (attributes, term, value) => {
     attributes.push({ type: 'ATOM', value: term.toUpperCase() });
 };
 
+/**
+ * Normalizes a user-supplied sequence set (string, number, bigint, or an array of
+ * them) into the single string value of a SEQUENCE token. An array is one
+ * comma-joined set: separate tokens would be parsed by the server as extra
+ * sequence-number search keys ANDed to the query, not as part of the set.
+ *
+ * @param {*} value - The sequence set value(s)
+ * @returns {string} The joined sequence set string
+ */
+let toSequenceValue = value => [].concat(value).join(',');
+
 /**
  * Adds a search option with its value(s) to the attributes array.
  * Handles NOT operations and array values.
@@ -37,23 +48,20 @@ let setBoolOpt = (attributes, term, value) => {
  * @param {Array} attributes - Array to append the attribute to
  * @param {string} term - The search term (e.g., 'FROM', 'SUBJECT')
  * @param {*} value - The value for the search term (string, array, or falsy for NOT)
- * @param {string} [type='ATOM'] - The attribute type
  */
-let setOpt = (attributes, term, value, type) => {
-    type = type || 'ATOM';
-
+let setOpt = (attributes, term, value) => {
     // Handle NOT operations for false or null values
     if (value === false || value === null) {
-        attributes.push({ type, value: 'NOT' });
+        attributes.push({ type: 'ATOM', value: 'NOT' });
     }
 
-    attributes.push({ type, value: term.toUpperCase() });
+    attributes.push({ type: 'ATOM', value: term.toUpperCase() });
 
-    // Handle array values (e.g., multiple UIDs)
+    // Handle array values (e.g. HEADER name/value pairs)
     if (Array.isArray(value)) {
-        value.forEach(entry => attributes.push({ type, value: (entry || '').toString() }));
+        value.forEach(entry => attributes.push({ type: 'ATOM', value: (entry || '').toString() }));
     } else {
-        attributes.push({ type, value: value.toString() });
+        attributes.push({ type: 'ATOM', value: value.toString() });
     }
 };
 
@@ -158,12 +166,12 @@ module.exports.searchCompiler = (connection, query) => {
                 // Custom sequence range support (non-standard)
                 case 'SEQ':
                     {
-                        let value = params[term];
-                        if (typeof value === 'number') {
-                            value = value.toString();
-                        }
-                        // Only accept valid sequence strings (no whitespace)
-                        if (typeof value === 'string' && /^\S+$/.test(value)) {
+                        // Passed through as a SEQUENCE token: the compiler validates the
+                        // set grammar and throws a coded error. An invalid value used to
+                        // be dropped silently here, which turned a bad filter into an
+                        // unrestricted search that matched every message.
+                        let value = params[term] || params[term] === 0 ? toSequenceValue(params[term]) : '';
+                        if (value) {
                             attributes.push({ type: 'SEQUENCE', value });
                         }
                     }
@@ -233,10 +241,13 @@ module.exports.searchCompiler = (connection, query) => {
                     }
                     break;
 
-                // UID sequences
+                // UID sequences. The key stays an ATOM and only the value is a
+                // SEQUENCE token, so the compiler validates the sequence set
+                // itself rather than the "UID" keyword in front of it.
                 case 'UID':
                     if (params[term]) {
-                        setOpt(attributes, term, params[term], 'SEQUENCE');
+                        attributes.push({ type: 'ATOM', value: 'UID' });
+                        attributes.push({ type: 'SEQUENCE', value: toSequenceValue(params[term]) });
                     }
                     break;
 

package/lib/tools.js

@@ -20,9 +20,13 @@ const EXPANDED_RANGE_LIMIT = 0x1000000;
 // 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,
 // 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.
+// stays gated on the BINARY token. SPECIAL-USE is a partial fold: Appendix E only
+// folds in the special-use mailbox attributes, not the RFC 6154 LIST selection and
+// RETURN options - the only call sites that act on this entry are in list.js,
+// where a staged retry ladder recovers if a rev2-only server rejects the RETURN
+// option. The set mirrors the rest of 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',
@@ -308,7 +312,17 @@ const tools = {
             return false;
         }
 
-        return (await compiler(response)).toString();
+        try {
+            return (await compiler(response)).toString();
+        } catch {
+            // The wire encoder refuses values that cannot be expressed as a valid IMAP
+            // string, which is what keeps user-supplied data from breaking out of a
+            // command. A server response is not held to that: the parser deliberately
+            // tolerates stray bytes inside an OK/NO/BAD atom, and those bytes then have
+            // no valid re-encoding. This text is diagnostic, so fall back to the logging
+            // encoder rather than replacing the server's error with an encoding failure.
+            return (await compiler(response, { isLogging: true })).toString();
+        }
     },
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.6.3",
+    "version": "1.6.5",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",

package/test/commands-integration-test.js

@@ -606,6 +606,97 @@ module.exports['Commands: search drops * from ESEARCH UID results'] = async test
     test.done();
 };
 
+module.exports['Commands: search discards invalid single values in an ESEARCH ALL set'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        mailbox: { path: 'INBOX', exists: 5 },
+        exec: async (cmd, attrs, opts) => {
+            // '0' is not a valid nz-number and 'foo' is garbage - both single
+            // values must be dropped while the valid one survives
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '0,foo,4' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, [4]);
+    test.done();
+};
+
+module.exports['Commands: search truncates single-value ESEARCH ALL entries at the mailbox size'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        mailbox: { path: 'INBOX', exists: 2 },
+        exec: async (cmd, attrs, opts) => {
+            // More single values than the mailbox holds - the walk must stop at
+            // the EXISTS budget instead of collecting the excess
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '1,2,3,4' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, [1, 2]);
+    test.done();
+};
+
+module.exports['Commands: search ignores an ESEARCH reply without attributes on the plain path'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            // A degenerate untagged ESEARCH with no attributes must not crash
+            // the collector or contribute results
+            await opts.untagged.ESEARCH({ attributes: null });
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '2' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, [2]);
+    test.done();
+};
+
+module.exports['Commands: search treats an ESEARCH ALL set without a mailbox size as empty'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        // No exists value at all - the budget is zero, nothing may be collected
+        mailbox: { path: 'INBOX' },
+        exec: async (cmd, attrs, opts) => {
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '1:3' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, []);
+    test.done();
+};
+
 module.exports['Commands: search with UID option'] = async test => {
     let execCmd = null;
     const connection = createMockConnection({
@@ -2819,6 +2910,40 @@ module.exports['Commands: compress handles error'] = async test => {
     test.done();
 };
 
+module.exports['Commands: compress fails the connection on trailing data'] = async test => {
+    // Per RFC 4978 the server switches to DEFLATE at its tagged OK, so data already
+    // buffered behind the OK was consumed as cleartext and the deflate stream is
+    // truncated. Declining the upgrade is not a protocol option at that point - the
+    // session is unrecoverable in both directions and must fail closed.
+    let closeAfterCalled = false;
+    let nextCalled = false;
+    const connection = createMockConnection({
+        capabilities: new Map([['COMPRESS=DEFLATE', true]]),
+        closeAfter: () => {
+            closeAfterCalled = true;
+        },
+        exec: async () => ({
+            hasTrailingData: true,
+            next: () => {
+                nextCalled = true;
+                test.ok(closeAfterCalled, 'teardown must be scheduled before parser backpressure is released');
+            }
+        })
+    });
+
+    let err = null;
+    try {
+        await compressCommand(connection);
+    } catch (e) {
+        err = e;
+    }
+    test.ok(err, 'compress must throw');
+    test.equal(err && err.code, 'COMPRESS_TRAILING_DATA');
+    test.ok(closeAfterCalled, 'the connection must be closed');
+    test.ok(nextCalled, 'parser backpressure must still be released');
+    test.done();
+};
+
 // ============================================
 // STARTTLS Command Tests
 // ============================================
@@ -3804,6 +3929,52 @@ module.exports['Commands: list runs separate INBOX query when using namespace']
     test.done();
 };
 
+module.exports['Commands: list INBOX fixup propagates non-reducible failures'] = async test => {
+    // Both sides of the fixup's retry guard: a NO on the extended call is an operational
+    // failure (not a RETURN options rejection), and a BAD on a call that already ran plain
+    // has no options left to reduce - neither may trigger the plain retry
+    for (let { capabilities, status } of [
+        {
+            capabilities: [
+                ['IMAP4rev1', true],
+                ['LIST-EXTENDED', true]
+            ],
+            status: 'NO'
+        },
+        { capabilities: [['IMAP4rev1', true]], status: 'BAD' }
+    ]) {
+        let listCalls = 0;
+        let lsubCalls = 0;
+        const connection = createMockConnection({
+            state: 3,
+            capabilities: new Map(capabilities),
+            exec: async (cmd, attrs) => {
+                if (cmd === 'LSUB') {
+                    lsubCalls++;
+                }
+                if (cmd === 'LIST') {
+                    listCalls++;
+                    if (attrs[1] === 'INBOX') {
+                        throw commandError('Command failed', status);
+                    }
+                }
+                return { next: () => {} };
+            }
+        });
+
+        try {
+            await listCommand(connection, 'Mail/', '*');
+            test.ok(false, 'Should have thrown');
+        } catch (err) {
+            test.equal(err.responseStatus, status);
+        }
+        // Main listing and the failed INBOX call - no plain retry, no LSUB merge
+        test.equal(listCalls, 2);
+        test.equal(lsubCalls, 0);
+    }
+    test.done();
+};
+
 module.exports['Commands: list handles LSUB merging'] = async test => {
     const connection = createMockConnection({
         state: 3,
@@ -4760,18 +4931,28 @@ module.exports['Commands: list discards partial results from a rejected INBOX fi
         state: 3,
         capabilities: new Map([
             ['IMAP4rev1', true],
-            ['LIST-EXTENDED', true]
+            ['LIST-EXTENDED', true],
+            ['SPECIAL-USE', true]
         ]),
         exec: async (cmd, attrs, opts) => {
             if (cmd === 'LIST') {
                 listAttempts.push(JSON.stringify(attrs));
                 if (listAttempts.length === 1) {
                     await opts.untagged.LIST({
-                        attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '.' }, { value: 'Prefix.Folder1' }]
+                        attributes: [
+                            [{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }, { value: '\\Sent' }],
+                            { value: '.' },
+                            { value: 'Prefix.Folder1' }
+                        ]
                     });
                 } else if (listAttempts.length === 2) {
-                    // The fixup attempt streams an untagged INBOX line and THEN gets
-                    // the tagged BAD - the partial line must not survive the retry
+                    // The fixup attempt streams untagged lines and THEN gets the tagged
+                    // BAD - the partial lines must not survive the retry. "Aliased" also
+                    // claims \Sent and sorts ahead of the main run's Prefix.Folder1, so
+                    // it would steal the special-use slot if it were not rolled back
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\Sent' }], { value: '.' }, { value: 'Aliased' }]
+                    });
                     await opts.untagged.LIST({
                         attributes: [[{ value: '\\HasNoChildren' }], { value: '.' }, { value: 'INBOX' }]
                     });
@@ -4790,7 +4971,9 @@ module.exports['Commands: list discards partial results from a rejected INBOX fi
     test.equal(listAttempts.length, 3);
     // Exactly one INBOX entry - the rejected attempt's partial line was discarded
     test.equal(result.filter(e => e.path === 'INBOX').length, 1);
-    test.ok(result.find(e => e.path === 'Prefix.Folder1'));
+    test.ok(!result.some(e => e.path === 'Aliased'), 'the rejected attempt entry is gone');
+    // The main run's special-use match survived the rollback of the rejected attempt
+    test.equal(result.find(e => e.path === 'Prefix.Folder1').specialUse, '\\Sent');
     test.done();
 };
 

package/test/idle-polling-test.js

@@ -347,3 +347,84 @@ module.exports['Polling: no polling session without a saved select command'] = a
     test.equal(connection.idling, false, 'idling untouched');
     test.done();
 };
+
+module.exports['Polling: a falsy STATUS result stops the loop as PollFailed'] = async test => {
+    await withFakeTimers(async timers => {
+        let warnings = [];
+        let connection = createConnection({
+            missingIdleCommand: 'STATUS',
+            // Only STATUS is ever polled; a failure without a NO status makes the
+            // real STATUS implementation swallow the error and return false
+            respond: async () => {
+                throw new Error('Command failed');
+            }
+        });
+        connection.log.warn = entry => warnings.push(entry);
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        await idlePromise;
+
+        test.ok(
+            warnings.some(entry => entry && entry.err && entry.err.code === 'PollFailed'),
+            'the falsy STATUS result surfaced as a PollFailed error'
+        );
+        test.equal(connection.idling, false, 'idling reset after the failed poll');
+        test.equal(connection.preCheck, false, 'preCheck released');
+        test.equal(timers.count(), 0, 'polling stopped');
+        test.done();
+    });
+};
+
+module.exports['Polling: a repeated break call is a no-op'] = async test => {
+    await withFakeTimers(async timers => {
+        let connection = createConnection();
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        test.deepEqual(connection.commands, ['NOOP'], 'the immediate first poll ran');
+
+        // A caller may hold on to the break function and invoke it more than once
+        let preCheck = connection.preCheck;
+        await preCheck();
+        await preCheck();
+        await idlePromise;
+
+        test.equal(connection.idling, false, 'idling reset');
+        test.equal(connection.preCheck, false, 'preCheck released');
+        test.equal(timers.count(), 0, 'no timer left armed');
+
+        await timers.fire();
+        test.deepEqual(connection.commands, ['NOOP'], 'no further poll after the duplicate break');
+        test.done();
+    });
+};
+
+module.exports['Polling: a break in the initiation tick prevents the first poll'] = async test => {
+    await withFakeTimers(async timers => {
+        let connection = createConnection();
+        // Simulate a break request (e.g. a command being queued) landing in the same
+        // tick the loop is initiated: trap the loop installing its own preCheck and
+        // break through it immediately, before the first poll has started
+        let installedPreCheck = connection.preCheck;
+        Object.defineProperty(connection, 'preCheck', {
+            get: () => installedPreCheck,
+            set: value => {
+                installedPreCheck = value;
+                if (typeof value === 'function') {
+                    value();
+                }
+            }
+        });
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        await idlePromise;
+
+        test.deepEqual(connection.commands, [], 'the already-cancelled session never polled');
+        test.equal(connection.idling, false, 'idling reset');
+        test.equal(connection.preCheck, false, 'preCheck released');
+        test.equal(timers.count(), 0, 'no timer left armed');
+        test.done();
+    });
+};