imapflow 1.4.9 → 1.6.0

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');
@@ -115,8 +113,9 @@ module.exports['imap-compiler: synchronizing literal with non-buffer value seeds
                 {
                     tag: '*',
                     command: 'CMD',
-                    // value is an object that is neither string/number/Buffer but has a numeric
-                    // length, so literalLength resolves to 10 while formatRespEntry(value, true)
+                    // value is an object that is neither string/number/Buffer, so the size
+                    // marker derives from the UTF-8 byte length of its stringified form
+                    // ('[object Object]', 15 bytes) while formatRespEntry(value, true)
                     // returns null -> the seeded resp falls back to [] (line 156 right side).
                     attributes: [{ type: 'LITERAL', value: { length: 10 } }]
                 },
@@ -125,7 +124,7 @@ module.exports['imap-compiler: synchronizing literal with non-buffer value seeds
         ).map(entry => entry.toString());
         // Only the header segment is emitted; the empty seeded data segment is dropped
         // because `if (resp.length)` is false at the end.
-        test.deepEqual(out, ['* CMD {10}\r\n']);
+        test.deepEqual(out, ['* CMD {15}\r\n']);
     });
 
 // STRING node with falsy value -> `(node.value || '')` right side (line 165).
@@ -303,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();
+};

package/test/imap-compiler-test.js

@@ -362,6 +362,91 @@ module.exports['IMAP Compiler: LITERAL literal8'] = test =>
         )
     );
 
+// RFC 7888 (folded into IMAP4rev2): with LITERAL- a non-synchronizing literal
+// marker {n+} is only allowed for literals of up to 4096 bytes - anything larger
+// must use the synchronizing {n} form, in every compilation mode
+module.exports['IMAP Compiler: LITERAL- oversized literal stays synchronizing in single-buffer mode'] = test =>
+    asyncWrapper(test, async test => {
+        let payload = 'a'.repeat(4097);
+        let compiled = (
+            await compiler(
+                {
+                    tag: '*',
+                    command: 'CMD',
+                    attributes: [
+                        {
+                            type: 'LITERAL',
+                            value: payload
+                        }
+                    ]
+                },
+                { literalMinus: true }
+            )
+        ).toString();
+        test.ok(compiled.startsWith('* CMD {4097}\r\n'), `must not use a non-synchronizing marker: ${compiled.slice(0, 20)}`);
+    });
+
+module.exports['IMAP Compiler: LITERAL- boundary: exactly 4096 bytes is non-synchronizing'] = test =>
+    asyncWrapper(test, async test => {
+        let payload = 'a'.repeat(4096);
+        let parts = (
+            await compiler(
+                {
+                    tag: '*',
+                    command: 'CMD',
+                    attributes: [
+                        {
+                            type: 'LITERAL',
+                            value: payload
+                        }
+                    ]
+                },
+                { asArray: true, literalMinus: true }
+            )
+        ).map(entry => entry.toString());
+        test.equal(parts.length, 1, 'literal must be appended inline without a continuation break');
+        test.ok(parts[0].startsWith('* CMD {4096+}\r\n'));
+    });
+
+module.exports['IMAP Compiler: LITERAL- boundary: 4097 bytes falls back to synchronizing'] = test =>
+    asyncWrapper(test, async test => {
+        let payload = 'a'.repeat(4097);
+        let parts = (
+            await compiler(
+                {
+                    tag: '*',
+                    command: 'CMD',
+                    attributes: [
+                        {
+                            type: 'LITERAL',
+                            value: payload
+                        }
+                    ]
+                },
+                { asArray: true, literalMinus: true }
+            )
+        ).map(entry => entry.toString());
+        test.equal(parts.length, 2, 'literal must wait for a continuation response');
+        test.ok(parts[0].endsWith('{4097}\r\n'), `marker must be synchronizing: ${parts[0].slice(-12)}`);
+    });
+
+// The literal size marker counts octets, not UTF-16 code units - a unicode string
+// value must declare its UTF-8 byte length
+module.exports['IMAP Compiler: LITERAL declares byte length for unicode string values'] = test =>
+    asyncWrapper(test, async test => {
+        let compiled = await compiler({
+            tag: '*',
+            command: 'CMD',
+            attributes: [
+                {
+                    type: 'LITERAL',
+                    value: 'Sõnumid'
+                }
+            ]
+        });
+        test.equal(compiled.toString(), '* CMD {8}\r\nSõnumid');
+    });
+
 module.exports['IMAP Compiler: LITERAL array 1'] = test =>
     asyncWrapper(test, async test =>
         test.deepEqual(

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

@@ -143,11 +143,23 @@ module.exports['Compress: session negotiates DEFLATE and runs commands'] = async
     client.write(Buffer.alloc(128 * 1024, 0x61));
     await new Promise(r => setTimeout(r, 50));
 
+    // Each stream owns and reports its own lifecycle: the compression PassThrough used to proxy
+    // the raw socket's `destroyed` getter, which made close() skip destroying it.
+    let rawSocket = client.socket;
+    let passThrough = client.writeSocket;
+    test.notEqual(passThrough, rawSocket, 'compression replaced the write socket with a PassThrough');
+    test.equal(passThrough.destroyed, false, 'the PassThrough reports its own state while alive');
+
     await client.logout();
     client.close();
     // close() must tear down the compression streams
     test.ok(!client._deflate, 'deflate cleaned up after close');
     test.ok(!client._inflate, 'inflate cleaned up after close');
+    test.ok(passThrough.destroyed, 'the compression PassThrough was destroyed');
+    test.ok(rawSocket.destroyed, 'the raw socket was destroyed');
+
+    // Repeated close() stays idempotent
+    test.doesNotThrow(() => client.close());
 
     server.close();
     test.done();

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

@@ -524,7 +524,7 @@ module.exports['Coverage: reader swallows a throwing untagged handler'] = async
 module.exports['Coverage: reader swallows a throwing trySend after a tagged response'] = async test => {
     let client = makeClient();
     let resolved = false;
-    client.currentRequest = { tag: 'A1' };
+    client.currentRequest = { tag: 'A1', sent: true };
     client.requestTagMap.set('A1', {
         command: 'NOOP',
         attributes: [],
@@ -549,7 +549,7 @@ module.exports['Coverage: reader handles compiler failure when building executed
     let client = makeClient();
     let rejected = null;
     // A request whose attributes cannot be compiled -> the executedCommand try/catch is hit
-    client.currentRequest = { tag: 'A1' };
+    client.currentRequest = { tag: 'A1', sent: true };
     client.requestTagMap.set('A1', {
         command: 'NOOP',
         // a circular/odd attribute that makes the logging compiler throw
@@ -576,7 +576,7 @@ module.exports['Coverage: reader handles compiler failure when building executed
 module.exports['Coverage: reader caps very large throttle backoff'] = async test => {
     let client = makeClient();
     let rejected = null;
-    client.currentRequest = { tag: 'A1' };
+    client.currentRequest = { tag: 'A1', sent: true };
     client.requestTagMap.set('A1', {
         command: 'FETCH',
         attributes: [],