imapflow 1.5.0 → 1.6.1

package/lib/tools.js

@@ -48,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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.5.0",
+    "version": "1.6.1",
     "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().
@@ -7312,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 => {
@@ -7325,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();
 };
 

package/test/fixtures/fake-timers.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// Deterministic stand-in for global.setTimeout/clearTimeout, so tests can drive timer-based
+// loops (auto-IDLE, IDLE restart, fallback polling) without wall-clock sleeps.
+//
+// It is the suite's existing "swap global.setTimeout for the duration of a test and restore it
+// in finally" idiom, made reusable and able to handle recursively scheduled timers: firing a
+// timer whose callback schedules the next one records the new timer instead of losing it.
+//
+// Only timers scheduled while installed are faked. Everything else (setImmediate, socket
+// timeouts, nodeunit's own bookkeeping) is untouched, and clearTimeout still forwards real
+// handles to the real implementation. Install for as short a window as possible and always
+// restore in a finally block.
+const installFakeTimers = () => {
+    const realSetTimeout = global.setTimeout;
+    const realClearTimeout = global.clearTimeout;
+
+    let seq = 0;
+    const timers = new Map();
+    // Every timer ever scheduled, including cleared and fired ones, so tests can assert timer
+    // identity and cleanup (which timer was armed, was it unref'd, was it cleared) without sleeps.
+    const history = [];
+
+    global.setTimeout = (fn, delay, ...args) => {
+        const id = ++seq;
+        const timer = { id, fn, delay, args, unrefd: false, cleared: false, fired: false };
+        timers.set(id, timer);
+        history.push(timer);
+        return {
+            _fakeTimerId: id,
+            unref() {
+                const timer = timers.get(id);
+                if (timer) {
+                    timer.unrefd = true;
+                }
+                return this;
+            },
+            ref() {
+                return this;
+            }
+        };
+    };
+
+    global.clearTimeout = handle => {
+        if (handle && handle._fakeTimerId) {
+            const timer = timers.get(handle._fakeTimerId);
+            if (timer) {
+                timer.cleared = true;
+                timers.delete(timer.id);
+            }
+            return;
+        }
+        return realClearTimeout(handle);
+    };
+
+    // Lets pending asynchronous work (a poll's promise chain) settle between timer firings.
+    const drain = async (turns = 3) => {
+        for (let i = 0; i < turns; i++) {
+            await new Promise(resolve => setImmediate(resolve));
+        }
+    };
+
+    return {
+        // Scheduled timers that have not fired or been cleared yet, in scheduling order
+        pending: () => Array.from(timers.values()).map(timer => ({ id: timer.id, delay: timer.delay, unrefd: timer.unrefd })),
+        count: () => timers.size,
+
+        // Every timer scheduled while installed, in scheduling order, with its final state
+        history: () => history.map(timer => ({ id: timer.id, delay: timer.delay, unrefd: timer.unrefd, cleared: timer.cleared, fired: timer.fired })),
+
+        // Fires every currently pending timer once, oldest first, letting async callbacks settle.
+        // Timers scheduled by those callbacks stay pending for the next fire() call, which is what
+        // makes a recursive loop (poll -> schedule -> poll) observable one step at a time.
+        fire: async () => {
+            const due = Array.from(timers.values());
+            for (const timer of due) {
+                if (!timers.has(timer.id)) {
+                    // cleared by an earlier callback in this batch
+                    continue;
+                }
+                timers.delete(timer.id);
+                timer.fired = true;
+                timer.fn(...timer.args);
+                await drain();
+            }
+        },
+
+        drain,
+
+        restore: () => {
+            global.setTimeout = realSetTimeout;
+            global.clearTimeout = realClearTimeout;
+            timers.clear();
+        }
+    };
+};
+
+/**
+ * Runs `fn` with faked timers installed, restoring the real ones afterwards. Always use this
+ * rather than installing by hand: leaking faked globals into the rest of the run breaks
+ * unrelated tests.
+ *
+ * @param {Function} fn - Receives the timer controller.
+ * @returns {Promise<*>} Whatever `fn` returns.
+ */
+const withFakeTimers = async fn => {
+    const timers = installFakeTimers();
+    try {
+        return await fn(timers);
+    } finally {
+        timers.restore();
+    }
+};
+
+module.exports = { installFakeTimers, withFakeTimers };

package/test/handler-branches-test.js

@@ -2,8 +2,6 @@
 
 'use strict';
 
-const proxyquire = require('proxyquire').noCallThru();
-
 const { parser, compiler } = require('../lib/handler/imap-handler');
 const { ImapStream } = require('../lib/handler/imap-stream');
 const { ParserInstance } = require('../lib/handler/parser-instance');
@@ -304,29 +302,6 @@ module.exports['search-compiler: keyword already present in mailbox flags is acc
 };
 
 // ============================================================================
-// proxy-connection.js
-// ============================================================================
-
-// attachEarlyErrorHandler guard (lines 23-25): the proxy client returns a truthy socket
-// that lacks an `.on` method, so the guard returns early.
-module.exports['proxy-connection: socket without .on skips early error handler attach'] = async test => {
-    let logger = { info: () => {}, error: () => {} };
-    let bareSocket = { write() {}, end() {} }; // truthy, but no .on
-    const { proxyConnection } = proxyquire('../lib/proxy-connection', {
-        'nodemailer/lib/smtp-connection/http-proxy-client': (url, port, host, cb) => {
-            cb(null, bareSocket);
-        },
-        socks: { SocksClient: {} },
-        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
-        net: { isIP: () => true }
-    });
-
-    let socket = await proxyConnection(logger, 'http://proxy.example.com:8080', '192.168.1.1', 993);
-    test.equal(socket, bareSocket, 'socket returned unchanged');
-    test.ok(!('_earlyErrorHandler' in socket), 'no early error handler was attached to a socket without .on');
-    test.done();
-};
-
 // Sanity: untagged parse still round-trips, just to keep the parser import exercised.
 module.exports['sanity: parser/compiler round-trip'] = test =>
     asyncWrapper(test, async test => {

package/test/idle-polling-test.js

@@ -0,0 +1,349 @@
+'use strict';
+
+// Fallback polling lifecycle (servers without IDLE): one explicitly identified polling session
+// that cannot run or reschedule after cancellation, reuses the real STATUS/SELECT state
+// handling, and always leaves `idling` describing reality.
+
+const idleCommand = require('../lib/commands/idle.js');
+const imapCommands = require('../lib/imap-commands.js');
+const { withFakeTimers } = require('./fixtures/fake-timers');
+
+const createConnection = (overrides = {}) => {
+    const states = { NOT_AUTHENTICATED: 1, AUTHENTICATED: 2, SELECTED: 3, LOGOUT: 4 };
+
+    const connection = {
+        states,
+        state: states.SELECTED,
+        id: 'polling-test',
+        capabilities: new Map(overrides.capabilities || []), // no IDLE -> polling fallback
+        enabled: new Set(overrides.enabled || []),
+        folders: new Map([['INBOX', { path: 'INBOX', delimiter: '/' }]]),
+        mailbox: {
+            path: 'INBOX',
+            exists: 3,
+            uidNext: 10,
+            uidValidity: BigInt(1),
+            highestModseq: BigInt(1)
+        },
+        namespace: { delimiter: '/', prefix: '' },
+        socket: { destroyed: false },
+        currentSelectCommand: { command: 'SELECT', arguments: [{ type: 'ATOM', value: 'INBOX' }] },
+        missingIdleCommand: 'NOOP',
+        idling: false,
+        preCheck: false,
+        events: [],
+        commands: [],
+        log: { warn: () => {}, info: () => {}, error: () => {}, debug: () => {}, trace: () => {} },
+        emit(event, payload) {
+            connection.events.push({ event, payload });
+        },
+        run: async () => false,
+        // Fallback polling dispatches through runInternal(), which ImapFlow resolves against the
+        // command registry - so a poll runs the real SELECT/STATUS implementation.
+        runInternal: async (command, ...args) => {
+            let handler = imapCommands.get(command.toUpperCase());
+            return handler ? await handler(connection, ...args) : false;
+        },
+        exec: async (command, attributes, options) => {
+            connection.commands.push(command);
+            return connection.respond(command, attributes, options);
+        },
+        respond: async () => ({ next: () => {}, response: { attributes: [{ value: 'OK' }] } })
+    };
+
+    // capabilities/enabled are already converted into a Map/Set above
+    let rest = Object.assign({}, overrides);
+    delete rest.capabilities;
+    delete rest.enabled;
+
+    return Object.assign(connection, rest);
+};
+
+module.exports['Polling: break before the first poll stops the loop'] = async test => {
+    await withFakeTimers(async timers => {
+        let connection = createConnection({
+            exec: async command => {
+                connection.commands.push(command);
+                // break while the very first poll is still in flight
+                await connection.preCheck();
+                return { next: () => {} };
+            }
+        });
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        await idlePromise;
+
+        test.deepEqual(connection.commands, ['NOOP'], 'only the immediate first poll ran');
+        test.equal(connection.idling, false, 'idling reset after the break');
+        test.equal(connection.preCheck, false, 'the session released preCheck');
+        test.equal(timers.count(), 0, 'no polling timer is left armed');
+
+        // Advancing several intervals must not produce another command
+        await timers.fire();
+        await timers.fire();
+        test.deepEqual(connection.commands, ['NOOP'], 'a cancelled session never polls again');
+        test.done();
+    });
+};
+
+module.exports['Polling: break during an in-flight poll cannot reschedule'] = async test => {
+    await withFakeTimers(async timers => {
+        let releasePoll;
+        let pollStarted;
+        let connection = createConnection({
+            exec: async command => {
+                connection.commands.push(command);
+                await new Promise(resolve => {
+                    releasePoll = resolve;
+                    if (pollStarted) {
+                        pollStarted();
+                    }
+                });
+                return { next: () => {} };
+            }
+        });
+
+        let started = new Promise(resolve => (pollStarted = resolve));
+        let idlePromise = idleCommand(connection, 60000);
+        await started;
+
+        // Cancel while the poll is still awaiting its response, then let it finish
+        await connection.preCheck();
+        releasePoll();
+        await idlePromise;
+
+        test.deepEqual(connection.commands, ['NOOP'], 'the in-flight poll completed but scheduled nothing');
+        test.equal(timers.count(), 0, 'the completing poll did not arm a new timer');
+        test.equal(connection.idling, false, 'idling reset');
+
+        await timers.fire();
+        test.deepEqual(connection.commands, ['NOOP'], 'no later command is sent');
+        test.done();
+    });
+};
+
+module.exports['Polling: break after a poll but before the next timer fires stops the loop'] = 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');
+        test.equal(timers.count(), 1, 'the next poll is scheduled');
+        test.ok(timers.pending()[0].unrefd, 'the background polling timer does not keep the process alive');
+
+        await connection.preCheck();
+        await idlePromise;
+
+        test.equal(timers.count(), 0, 'the armed timer was cleared on cancellation');
+
+        await timers.fire();
+        await timers.fire();
+        test.deepEqual(connection.commands, ['NOOP'], 'no command after cancellation');
+        test.done();
+    });
+};
+
+module.exports['Polling: an old session does not clear a newer session preCheck'] = async test => {
+    await withFakeTimers(async timers => {
+        let releasePoll;
+        let pollStarted;
+        let connection = createConnection({
+            exec: async command => {
+                connection.commands.push(command);
+                if (connection.commands.length === 1) {
+                    await new Promise(resolve => {
+                        releasePoll = resolve;
+                        pollStarted();
+                    });
+                }
+                return { next: () => {} };
+            }
+        });
+
+        let started = new Promise(resolve => (pollStarted = resolve));
+        let firstSession = idleCommand(connection, 60000);
+        await started;
+
+        // Cancel the first session while its poll is in flight, then immediately re-enter IDLE
+        await connection.preCheck();
+        let secondSession = idleCommand(connection, 60000);
+        await timers.drain();
+
+        let newPreCheck = connection.preCheck;
+        test.equal(typeof newPreCheck, 'function', 'the new session installed its own preCheck');
+
+        // The stale poll now finishes: it must not touch the new session's ownership
+        releasePoll();
+        await firstSession;
+
+        test.equal(connection.preCheck, newPreCheck, 'the stale session left the newer preCheck in place');
+        test.equal(connection.idling, true, 'the stale session did not clear the newer idling state');
+
+        await connection.preCheck();
+        await secondSession;
+        test.equal(connection.idling, false, 'the newer session cleaned up on its own break');
+        test.done();
+    });
+};
+
+module.exports['Polling: STATUS polling applies mailbox state and emits exists only on change'] = async test => {
+    await withFakeTimers(async timers => {
+        let messages = 3;
+        let connection = createConnection({
+            capabilities: [['CONDSTORE', true]],
+            missingIdleCommand: 'STATUS',
+            respond: async (command, attributes, options) => {
+                if (command === 'STATUS') {
+                    let statusHandler = options.untagged.STATUS;
+                    await statusHandler({
+                        attributes: [
+                            { type: 'STRING', value: 'INBOX' },
+                            [
+                                { type: 'ATOM', value: 'MESSAGES' },
+                                { type: 'ATOM', value: String(messages) },
+                                { type: 'ATOM', value: 'UIDNEXT' },
+                                { type: 'ATOM', value: '11' },
+                                { type: 'ATOM', value: 'HIGHESTMODSEQ' },
+                                { type: 'ATOM', value: '42' }
+                            ]
+                        ]
+                    });
+                }
+                return { next: () => {}, response: { attributes: [{ value: 'OK' }] } };
+            }
+        });
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+
+        test.deepEqual(connection.commands, ['STATUS'], 'STATUS was used for polling');
+        test.equal(connection.mailbox.uidNext, 11, 'uidNext updated from the poll');
+        test.equal(connection.mailbox.highestModseq, BigInt(42), 'highestModseq updated on a CONDSTORE session');
+        test.deepEqual(connection.events, [], 'an unchanged message count emits no event');
+
+        // Second poll reports a new count -> exactly one exists event
+        messages = 5;
+        await timers.fire();
+
+        test.equal(connection.mailbox.exists, 5, 'exists updated from the poll');
+        test.equal(connection.events.length, 1, 'one event for the changed count');
+        test.equal(connection.events[0].event, 'exists');
+        test.equal(connection.events[0].payload.count, 5);
+        test.equal(connection.events[0].payload.prevCount, 3);
+
+        await connection.preCheck();
+        await idlePromise;
+        test.done();
+    });
+};
+
+module.exports['Polling: STATUS omits HIGHESTMODSEQ without CONDSTORE'] = async test => {
+    await withFakeTimers(async timers => {
+        let requestedItems = [];
+        let connection = createConnection({
+            missingIdleCommand: 'STATUS',
+            respond: async (command, attributes) => {
+                if (command === 'STATUS') {
+                    requestedItems = attributes[1].map(entry => entry.value);
+                }
+                return { next: () => {}, response: { attributes: [{ value: 'OK' }] } };
+            }
+        });
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+
+        test.ok(requestedItems.includes('MESSAGES'), 'MESSAGES is polled');
+        test.ok(requestedItems.includes('UIDNEXT'), 'UIDNEXT is polled');
+        test.ok(!requestedItems.includes('HIGHESTMODSEQ'), 'HIGHESTMODSEQ is not requested without CONDSTORE');
+
+        await connection.preCheck();
+        await idlePromise;
+        test.done();
+    });
+};
+
+module.exports['Polling: failed SELECT polling deselects and stops the loop'] = async test => {
+    await withFakeTimers(async timers => {
+        let connection = createConnection({
+            missingIdleCommand: 'SELECT',
+            respond: async command => {
+                if (command === 'SELECT') {
+                    let err = new Error('Command failed');
+                    err.responseStatus = 'NO';
+                    throw err;
+                }
+                return { next: () => {}, response: { attributes: [{ value: 'OK' }] } };
+            }
+        });
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        await idlePromise;
+
+        test.equal(connection.state, connection.states.AUTHENTICATED, 'a failed reselect drops to AUTHENTICATED');
+        test.equal(connection.mailbox, false, 'mailbox state cleared');
+        test.equal(connection.currentSelectCommand, false, 'the saved select command is cleared');
+        test.equal(connection.idling, false, 'idling reset');
+        test.equal(connection.preCheck, false, 'preCheck released');
+        test.equal(timers.count(), 0, 'polling stopped');
+        test.ok(
+            connection.events.some(entry => entry.event === 'mailboxClose'),
+            'the mailbox close transition was emitted, as with a caller-issued SELECT'
+        );
+        test.done();
+    });
+};
+
+module.exports['Polling: a closed connection stops the loop instead of polling'] = async test => {
+    await withFakeTimers(async timers => {
+        let connection = createConnection();
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        test.deepEqual(connection.commands, ['NOOP'], 'first poll ran on a live connection');
+
+        // Transport dies between polls
+        connection.socket.destroyed = true;
+        await timers.fire();
+        await idlePromise;
+
+        test.deepEqual(connection.commands, ['NOOP'], 'no command is sent on a dead transport');
+        test.equal(connection.idling, false, 'idling reset when the loop stops');
+        test.equal(connection.preCheck, false, 'preCheck released');
+        test.done();
+    });
+};
+
+module.exports['Polling: a rejected poll resets idling'] = async test => {
+    await withFakeTimers(async timers => {
+        let connection = createConnection({
+            exec: async command => {
+                connection.commands.push(command);
+                let err = new Error('Connection not available');
+                err.code = 'NoConnection';
+                throw err;
+            }
+        });
+
+        let idlePromise = idleCommand(connection, 60000);
+        await timers.drain();
+        await idlePromise;
+
+        test.equal(connection.idling, false, 'idling reset after a rejected poll');
+        test.equal(connection.preCheck, false, 'preCheck released after a rejected poll');
+        test.equal(timers.count(), 0, 'nothing left scheduled');
+        test.done();
+    });
+};
+
+module.exports['Polling: no polling session without a saved select command'] = async test => {
+    let connection = createConnection({ currentSelectCommand: false });
+    await idleCommand(connection, 60000);
+    test.deepEqual(connection.commands, [], 'nothing polled');
+    test.equal(connection.idling, false, 'idling untouched');
+    test.done();
+};