imapflow 1.3.5 → 1.3.7

package/test/imap-formal-syntax-test.js

@@ -273,3 +273,21 @@ module.exports['Formal Syntax: CHAR() returns same string reference on repeated
     test.strictEqual(first, second);
     test.done();
 };
+
+// Memoization: the second invocation must return the cached value via the
+// rewritten getter (covers the memoized inner functions).
+module.exports['Formal Syntax: atom-specials is memoized across calls'] = test => {
+    let first = imapFormalSyntax['atom-specials']();
+    let second = imapFormalSyntax['atom-specials']();
+    test.equal(first, second);
+    test.ok(second.includes('('));
+    test.done();
+};
+
+module.exports['Formal Syntax: quoted-specials is memoized across calls'] = test => {
+    let first = imapFormalSyntax['quoted-specials']();
+    let second = imapFormalSyntax['quoted-specials']();
+    test.equal(first, second);
+    test.ok(second.includes('"'));
+    test.done();
+};

package/test/imap-parser-test.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const { parser } = require('../lib/handler/imap-handler');
+const { ParserInstance } = require('../lib/handler/parser-instance');
 const mimetorture = require('./fixtures/serialized-mimetorture');
 
 let asyncWrapper = (test, handler) => {
@@ -26,6 +27,20 @@ let asyncWrapperFail = (test, handler) => {
         });
 };
 
+// Asserts that `fn` throws (or rejects with) an error carrying the expected `code`,
+// not merely that *some* error was thrown.
+let expectErrorCode = (test, code, fn) =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await fn();
+        } catch (e) {
+            err = e;
+        }
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err && err.code, code);
+    });
+
 module.exports['IMAP Parser: Tags: get TAG'] = test => asyncWrapper(test, async test => test.equal((await parser('TAG1 CMD')).tag, 'TAG1'));
 module.exports['IMAP Parser: Tags: space before TAG'] = test => asyncWrapperFail(test, async test => test.ok(await parser(' TAG CMD')));
 module.exports['IMAP Parser: Tags: fail empty TAG'] = test => asyncWrapperFail(test, async test => test.ok(await parser('')));
@@ -319,6 +334,43 @@ module.exports['IMAP Parser: Literals: literal with NULL'] = test =>
         ])
     );
 
+module.exports['IMAP Parser: empty continuation (+) response'] = test =>
+    asyncWrapper(test, async test => {
+        let parsed = await parser('+');
+        test.equal(parsed.tag, '+');
+        test.equal(parsed.command, '');
+    });
+
+module.exports['IMAP Parser: non-space after command throws ParserError5'] = test =>
+    expectErrorCode(test, 'ParserError5', () => parser('TAG1 CMD\tx'));
+
+module.exports['IMAP Parser: leading whitespace in attributes throws ParserError7'] = test =>
+    expectErrorCode(test, 'ParserError7', () => parser('TAG1 CMD \tx'));
+
+module.exports['IMAP Parser: getAttributes on empty input throws ParserError6'] = test =>
+    expectErrorCode(test, 'ParserError6', () => {
+        // constructed without options to also exercise the options default branch
+        let pi = new ParserInstance('');
+        return pi.getAttributes();
+    });
+
+module.exports['IMAP Parser: strips leading NUL padding and records count'] = test =>
+    asyncWrapper(test, async test => {
+        let buf = Buffer.concat([Buffer.from([0, 0, 0]), Buffer.from('* OK ready')]);
+        let parsed = await parser(buf);
+        test.equal(parsed.tag, '*');
+        test.equal(parsed.command, 'OK');
+        test.equal(parsed.nullBytesRemoved, 3);
+    });
+
+module.exports['IMAP Parser: all-NUL input becomes BAD response'] = test =>
+    asyncWrapper(test, async test => {
+        let parsed = await parser(Buffer.from([0, 0, 0, 0]));
+        test.equal(parsed.tag, '*');
+        test.equal(parsed.command, 'BAD');
+        test.deepEqual(parsed.attributes, []);
+    });
+
 module.exports['IMAP Parser: Literals: literal8'] = test =>
     asyncWrapper(test, async test =>
         test.deepEqual((await parser('TAG1 CMD ~{4}\r\n', { literals: [Buffer.from('ab\x00d')] })).attributes, [

package/test/imap-stream-edge-cases-test.js

@@ -131,6 +131,64 @@ module.exports['LiteralTooLarge error'] = test => {
     stream.write(Buffer.from('A APPEND {1073741825}\r\n'));
 };
 
+module.exports['LiteralTooLarge error honors configured maxLiteralSize'] = test => {
+    const cap = 1024; // 1KB cap
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: cap });
+
+    stream.on('error', err => {
+        test.equal(err.code, 'LiteralTooLarge', 'error code should be LiteralTooLarge');
+        test.equal(err.maxSize, cap, 'maxSize should reflect the configured cap');
+        test.equal(err.literalSize, 2048, 'literalSize should be the offending value');
+        stream.destroy();
+        test.done();
+    });
+
+    stream.write(Buffer.from('A APPEND {2048}\r\n'));
+};
+
+module.exports['maxLiteralSize: 0 is honored (not swallowed into the default)'] = test => {
+    // Regression: `this.options.maxLiteralSize || MAX_LITERAL_SIZE` turned an explicit 0 into
+    // the 1GB default. An explicit 0 must mean "reject any non-empty literal".
+    test.expect(2);
+
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: 0 });
+    test.equal(stream.maxLiteralSize, 0, 'an explicit 0 cap is preserved, not replaced by the default');
+
+    stream.on('error', err => {
+        test.equal(err.code, 'LiteralTooLarge', 'a 1-byte literal exceeds the 0 cap');
+        stream.destroy();
+        test.done();
+    });
+
+    stream.write(Buffer.from('A APPEND {1}\r\n'));
+};
+
+module.exports['Literal within configured maxLiteralSize parses cleanly'] = test => {
+    // Require both literal assertions to actually run: 'end' fires even if the parser never
+    // emits the command, so without expect() a dropped-literal regression would pass green.
+    test.expect(2);
+
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: 1024 });
+    const literal = Buffer.alloc(512, 0x61); // 512 * 'a'
+
+    stream.on('readable', () => {
+        let cmd;
+        while ((cmd = stream.read()) !== null) {
+            test.equal(cmd.literals.length, 1, 'should have one literal');
+            test.equal(cmd.literals[0].length, 512, 'literal length should be 512');
+            cmd.next();
+        }
+    });
+
+    stream.on('error', err => test.ifError(err));
+
+    stream.on('end', () => test.done());
+
+    stream.write(Buffer.from('A APPEND {512}\r\n'));
+    stream.write(literal);
+    stream.end(Buffer.from('\r\n'));
+};
+
 module.exports['Incomplete line continued in next chunk'] = test => {
     runStreamTest(
         test,
@@ -334,3 +392,67 @@ module.exports['Line length cap allows line within limit'] = test => {
 
     stream.end(Buffer.from('A NOOP\r\n'));
 };
+
+// ---------------------------------------------------------------------------
+// checkLiteralMarker direct edge cases + _transform string handling + _destroy
+// draining (lines that the normal streaming flow does not exercise).
+// ---------------------------------------------------------------------------
+
+module.exports['ImapStream: checkLiteralMarker returns false for empty line'] = test => {
+    const stream = new ImapStream({ cid: 't' });
+    test.equal(stream.checkLiteralMarker(Buffer.alloc(0)), false);
+    test.equal(stream.checkLiteralMarker(null), false);
+    test.done();
+};
+
+module.exports['ImapStream: checkLiteralMarker returns false when no trailing LF'] = test => {
+    const stream = new ImapStream({ cid: 't' });
+    test.equal(stream.checkLiteralMarker(Buffer.from('A1 OK no newline')), false);
+    test.done();
+};
+
+module.exports['ImapStream: checkLiteralMarker returns false for non-numeric marker'] = test => {
+    const stream = new ImapStream({ cid: 't' });
+    // '{' present but contains a non-digit, and an empty {} marker
+    test.equal(stream.checkLiteralMarker(Buffer.from('A1 CMD {x}\r\n')), false);
+    test.equal(stream.checkLiteralMarker(Buffer.from('A1 CMD {}\r\n')), false);
+    test.done();
+};
+
+module.exports['ImapStream: checkLiteralMarker activates literal state for valid marker'] = test => {
+    const stream = new ImapStream({ cid: 't' });
+    test.equal(stream.checkLiteralMarker(Buffer.from('A1 CMD {5}\r\n')), true);
+    test.equal(stream.literalWaiting, 5);
+    test.done();
+};
+
+module.exports['ImapStream: _transform converts string chunks to Buffer'] = test => {
+    const stream = new ImapStream({ cid: 't' });
+    let commands = [];
+    stream.on('readable', () => {
+        let cmd;
+        while ((cmd = stream.read()) !== null) {
+            commands.push(cmd.payload.toString());
+            cmd.next();
+        }
+    });
+    stream.on('end', () => {
+        test.ok(commands.some(c => /A1 OK/.test(c)));
+        test.done();
+    });
+    // write a string (not a Buffer) to exercise the string->Buffer branch
+    stream.write('A1 OK done\r\n');
+    stream.end();
+};
+
+module.exports['ImapStream: _destroy drains pending input queue callbacks'] = test => {
+    const stream = new ImapStream({ cid: 't' });
+    let nextCalled = false;
+    // Stage a pending queue item with a next() callback, then destroy.
+    stream.inputQueue.push({ chunk: Buffer.from('x'), next: () => (nextCalled = true) });
+    stream.destroy();
+    setImmediate(() => {
+        test.ok(nextCalled, 'pending next() invoked during destroy');
+        test.done();
+    });
+};

package/test/jp-decoder-test.js

@@ -2,6 +2,7 @@
 
 const { JPDecoder } = require('../lib/jp-decoder');
 const { PassThrough, Transform } = require('stream');
+const encodingJapanese = require('encoding-japanese');
 
 // Helper to collect stream output
 const collectStream = stream =>
@@ -126,6 +127,53 @@ module.exports['JPDecoder: _flush handles conversion errors gracefully'] = async
     test.done();
 };
 
+module.exports['JPDecoder: _flush falls back to raw input when convert throws'] = async test => {
+    // encoding-japanese rarely throws on its own, so force it: the module object
+    // is shared by reference with the copy held inside jp-decoder.js, so patching
+    // .convert here affects the decoder's call too.
+    let originalConvert = encodingJapanese.convert;
+    encodingJapanese.convert = () => {
+        throw new Error('forced conversion failure');
+    };
+
+    try {
+        let decoder = new JPDecoder('iso-2022-jp');
+        let output = collectStream(decoder);
+
+        let input = Buffer.from('raw bytes preserved');
+        decoder.write(input);
+        decoder.end();
+
+        let result = await output;
+        // On a thrown error the catch block pushes the original, untouched input
+        test.equal(result.toString(), 'raw bytes preserved');
+    } finally {
+        encodingJapanese.convert = originalConvert;
+    }
+    test.done();
+};
+
+module.exports['JPDecoder: _flush converts non-string convert output to buffer'] = async test => {
+    // When convert returns a non-string (e.g. an array of code units), it must be
+    // pushed as-is without the Buffer.from(string) branch.
+    let originalConvert = encodingJapanese.convert;
+    encodingJapanese.convert = () => Buffer.from('converted buffer');
+
+    try {
+        let decoder = new JPDecoder('iso-2022-jp');
+        let output = collectStream(decoder);
+
+        decoder.write(Buffer.from('whatever'));
+        decoder.end();
+
+        let result = await output;
+        test.equal(result.toString(), 'converted buffer');
+    } finally {
+        encodingJapanese.convert = originalConvert;
+    }
+    test.done();
+};
+
 module.exports['JPDecoder: _flush handles empty input'] = async test => {
     let decoder = new JPDecoder('iso-2022-jp');
     let output = collectStream(decoder);

package/test/limited-passthrough-test.js

@@ -142,6 +142,23 @@ module.exports['LimitedPassthrough: zero maxBytes treated as Infinity'] = async
     test.done();
 };
 
+module.exports['LimitedPassthrough: drops chunk when no remaining budget but not yet limited'] = async test => {
+    // Force the remainingBytes<1 guard (distinct from the `this.limited` fast path):
+    // override maxBytes to 0 after construction so the very first chunk hits it
+    // while `limited` is still false.
+    let stream = new LimitedPassthrough();
+    stream.maxBytes = 0;
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('dropped'));
+    stream.end();
+
+    let result = await output;
+    test.equal(result.length, 0, 'chunk dropped when no budget remains');
+    test.equal(stream.limited, false, 'limited flag never set via this path');
+    test.done();
+};
+
 module.exports['LimitedPassthrough: handles limit of 1 byte'] = async test => {
     let stream = new LimitedPassthrough({ maxBytes: 1 });
     let output = collectStream(stream);

package/test/proxy-connection-test.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const proxyquire = require('proxyquire').noCallThru();
+const { EventEmitter } = require('events');
 
 // Mock socket object
 const createMockSocket = () => ({
@@ -10,6 +11,16 @@ const createMockSocket = () => ({
     destroy: () => {}
 });
 
+// Real EventEmitter-backed mock socket, for tests that need listener tracking / emit.
+const createMockEmitterSocket = () => Object.assign(new EventEmitter(), { write() {}, end() {}, destroy() {} });
+
+// Asserts proxyConnection returned the socket and guarded it with an error listener.
+const assertEarlyErrorHandler = (test, socket, mockSocket) => {
+    test.equal(socket, mockSocket);
+    test.ok(socket.listenerCount('error') >= 1, 'proxy socket carries an error listener before being returned');
+    test.doesNotThrow(() => socket.emit('error', new Error('early proxy error')), 'an early proxy socket error does not throw');
+};
+
 // Mock logger
 const createMockLogger = () => {
     const logs = { info: [], error: [] };
@@ -539,3 +550,78 @@ module.exports['Proxy Connection: SOCKS with username only'] = async test => {
     await proxyConnection(logger, 'socks5://testuser@proxy.example.com:1080', '192.168.1.1', 993);
     test.done();
 };
+
+// ============================================
+// Early error handler (no unhandled 'error' before ImapFlow takes over)
+// ============================================
+
+module.exports['Proxy Connection: HTTP socket has early error handler before return'] = async test => {
+    const mockSocket = createMockEmitterSocket();
+    const logger = createMockLogger();
+
+    const { proxyConnection } = proxyquire('../lib/proxy-connection', {
+        'nodemailer/lib/smtp-connection/http-proxy-client': (url, port, host, cb) => {
+            cb(null, mockSocket);
+        },
+        socks: { SocksClient: {} },
+        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
+        net: { isIP: () => true }
+    });
+
+    const socket = await proxyConnection(logger, 'http://proxy.example.com:8080', '192.168.1.1', 993);
+
+    assertEarlyErrorHandler(test, socket, mockSocket);
+    test.done();
+};
+
+module.exports['Proxy Connection: SOCKS socket has early error handler before return'] = async test => {
+    const mockSocket = createMockEmitterSocket();
+    const logger = createMockLogger();
+
+    const { proxyConnection } = proxyquire('../lib/proxy-connection', {
+        'nodemailer/lib/smtp-connection/http-proxy-client': () => {},
+        socks: {
+            SocksClient: {
+                createConnection: async () => ({ socket: mockSocket })
+            }
+        },
+        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
+        net: { isIP: () => true }
+    });
+
+    const socket = await proxyConnection(logger, 'socks5://proxy.example.com:1080', '192.168.1.1', 993);
+
+    assertEarlyErrorHandler(test, socket, mockSocket);
+    test.done();
+};
+
+// detachEarlyErrorHandler must remove the guard once the caller takes ownership of the socket,
+// so it no longer swallows/logs errors meant for the new owner's handlers.
+module.exports['Proxy Connection: detachEarlyErrorHandler removes the early guard'] = async test => {
+    const mockSocket = createMockEmitterSocket();
+    const logger = createMockLogger();
+
+    const { proxyConnection, detachEarlyErrorHandler } = proxyquire('../lib/proxy-connection', {
+        'nodemailer/lib/smtp-connection/http-proxy-client': (url, port, host, cb) => {
+            cb(null, mockSocket);
+        },
+        socks: { SocksClient: {} },
+        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
+        net: { isIP: () => true }
+    });
+
+    const socket = await proxyConnection(logger, 'http://proxy.example.com:8080', '192.168.1.1', 993);
+    test.ok(socket.listenerCount('error') >= 1, 'early error handler attached on return');
+    test.ok(typeof socket._earlyErrorHandler === 'function', 'handler reference stored on the socket');
+
+    detachEarlyErrorHandler(socket);
+
+    test.equal(socket.listenerCount('error'), 0, 'early error handler removed after detach');
+    test.equal(socket._earlyErrorHandler, null, 'stored handler reference cleared');
+
+    // Detaching again (or on a bare socket) must be a safe no-op.
+    test.doesNotThrow(() => detachEarlyErrorHandler(socket));
+    test.doesNotThrow(() => detachEarlyErrorHandler(createMockEmitterSocket()));
+
+    test.done();
+};

package/test/reliability-improvements-test.js

@@ -368,3 +368,91 @@ module.exports['Reliability: decoder emit(error) does not crash when user has no
 
     test.done();
 };
+
+// ============================================================================
+// Throttle back-off timer is tracked and abortable on close()
+// ============================================================================
+
+// Feed a single throttling BAD response into reader() once, then null.
+const stubThrottleResponse = (client, backoffMs) => {
+    let request = { tag: 'A001', command: 'FETCH', resolve: () => {}, reject: () => {} };
+    client.requestTagMap = new Map([['A001', request]]);
+
+    let done = false;
+    client.streamer.read = () => {
+        if (done) {
+            return null;
+        }
+        done = true;
+        return {
+            payload: Buffer.from(`A001 BAD Request is throttled. Suggested Backoff Time: ${backoffMs} milliseconds`),
+            literals: [],
+            next: () => {}
+        };
+    };
+
+    return request;
+};
+
+module.exports['Reliability: throttle back-off aborts promptly on close()'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' },
+        logger: false
+    });
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.writeSocket = client.socket;
+
+    let rejected = null;
+    let request = stubThrottleResponse(client, 300000); // 5 min back-off
+    request.reject = err => {
+        rejected = err;
+    };
+
+    let start = Date.now();
+    let readerDone = client.reader().catch(() => {});
+
+    // Let reader() reach the (tracked) back-off wait.
+    await new Promise(r => setTimeout(r, 50));
+    test.ok(client._throttleTimer, 'back-off timer is tracked while waiting');
+
+    client.close();
+    await new Promise(r => setImmediate(r));
+
+    test.ok(rejected, 'request rejected promptly after close()');
+    test.equal(rejected.code, 'NoConnection', 'rejected with connection error, not ETHROTTLE');
+    test.equal(client._throttleTimer, null, 'throttle timer cleared on close()');
+    test.ok(Date.now() - start < 5000, 'settled well under the 5-minute cap');
+
+    await readerDone;
+    test.done();
+};
+
+module.exports['Reliability: throttle back-off still rejects ETHROTTLE on normal expiry'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' },
+        logger: false
+    });
+
+    let rejected = null;
+    let request = stubThrottleResponse(client, 50); // 50ms back-off
+    request.reject = err => {
+        rejected = err;
+    };
+
+    let readerDone = client.reader().catch(() => {});
+
+    await new Promise(r => setTimeout(r, 250));
+
+    test.ok(rejected, 'request rejected after the back-off elapses');
+    test.equal(rejected.code, 'ETHROTTLE', 'normal expiry still rejects ETHROTTLE');
+    test.equal(rejected.throttleReset, 50, 'throttleReset preserved');
+    test.equal(client._throttleTimer, null, 'throttle timer cleared after normal expiry');
+
+    await readerDone;
+    client.close();
+    test.done();
+};

package/test/search-compiler-test.js

@@ -844,6 +844,37 @@ module.exports['Search Compiler: HEADER with Unicode adds CHARSET'] = test => {
     test.done();
 };
 
+module.exports['Search Compiler: non-ASCII text field adds CHARSET UTF-8'] = test => {
+    let connection = createMockConnection({
+        enabled: new Set() // UTF8=ACCEPT not enabled
+    });
+    // Non-ASCII subject must flip hasUnicode and prepend CHARSET UTF-8
+    let compiled = searchCompiler(connection, { subject: 'résumé café' });
+    test.ok(hasAttr(compiled, 'CHARSET'));
+    test.ok(hasAttr(compiled, 'UTF-8'));
+    test.done();
+};
+
+module.exports['Search Compiler: non-ASCII body field adds CHARSET UTF-8'] = test => {
+    let connection = createMockConnection({
+        enabled: new Set()
+    });
+    let compiled = searchCompiler(connection, { body: 'Grüße' });
+    test.ok(hasAttr(compiled, 'CHARSET'));
+    test.done();
+};
+
+module.exports['Search Compiler: non-ASCII GMRAW adds CHARSET UTF-8'] = test => {
+    let connection = createMockConnection({
+        capabilities: [['X-GM-EXT-1', true]],
+        enabled: new Set()
+    });
+    let compiled = searchCompiler(connection, { gmraw: 'subject:café' });
+    test.ok(hasAttr(compiled, 'CHARSET'));
+    test.ok(hasAttr(compiled, 'X-GM-RAW'));
+    test.done();
+};
+
 // ============================================
 // Complex query tests
 // ============================================

package/test/search-test.js

@@ -160,6 +160,67 @@ module.exports['ESEARCH: no RETURN clause when server lacks ESEARCH capability']
     }).catch(err => test.done(err));
 };
 
+module.exports['ESEARCH: parseEsearchResponse skips non-ATOM tokens'] = test => {
+    const attrs = [
+        [{ type: 'ATOM', value: 'stray' }], // non-ATOM (Array) token is skipped
+        { type: 'ATOM', value: 'COUNT' },
+        { type: 'ATOM', value: '9' }
+    ];
+    const result = parseEsearchResponse(attrs);
+    test.equal(result.count, 9);
+    test.done();
+};
+
+module.exports['ESEARCH: parseEsearchResponse skips trailing key with no value'] = test => {
+    const attrs = [{ type: 'ATOM', value: 'COUNT' }]; // dangling key, no value
+    const result = parseEsearchResponse(attrs);
+    test.deepEqual(result, {});
+    test.done();
+};
+
+module.exports['ESEARCH: untagged handler parses ESEARCH response'] = test => {
+    const conn = makeConnection({ hasEsearch: true });
+    conn.exec = async (command, attributes, handlers) => {
+        const esearch = handlers && handlers.untagged && handlers.untagged.ESEARCH;
+        // leading (TAG "A1") list + UID atom are stripped before parsing
+        await esearch({
+            attributes: [
+                [
+                    { type: 'ATOM', value: 'TAG' },
+                    { type: 'STRING', value: 'A1' }
+                ],
+                { type: 'ATOM', value: 'UID' },
+                { type: 'ATOM', value: 'COUNT' },
+                { type: 'ATOM', value: '7' }
+            ]
+        });
+        // also exercise the empty-attributes guard
+        await esearch({ attributes: null });
+        return { next: () => {} };
+    };
+    searchCmd(conn, { seen: false }, { uid: true, returnOptions: ['COUNT'] })
+        .then(result => {
+            test.equal(result.count, 7);
+            test.done();
+        })
+        .catch(err => test.done(err));
+};
+
+module.exports['ESEARCH: command path returns false on exec error'] = test => {
+    const conn = makeConnection({ hasEsearch: true });
+    conn.exec = async () => {
+        let err = new Error('search failed');
+        err.responseStatus = 'NO';
+        throw err;
+    };
+    searchCmd(conn, { seen: false }, { uid: true, returnOptions: ['COUNT'] })
+        .then(result => {
+            test.equal(result, false);
+            test.done();
+        })
+        .catch(err => test.done(err));
+};
+
 module.exports['ESEARCH: parseEsearchResponse ignores unknown keywords'] = test => {
     // Dovecot with CONDSTORE may append MODSEQ to ESEARCH responses
     const attrs = [