imapflow 1.3.6 → 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

@@ -392,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/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 = [

package/test/token-parser-test.js

@@ -390,3 +390,67 @@ module.exports['Token Parser: malformed REFERRAL with no closing bracket consume
         test.equal(section[0].value, 'REFERRAL');
         test.equal(section[1].value, 'imap://user@host/INBOX');
     });
+
+// ---------------------------------------------------------------------------
+// Additional error-path and edge-case coverage (E11, E12, E16, E17, E19-E22,
+// E24, E27) plus the bare-"*" sequence and "~"-as-atom normalization paths.
+// All use a non-status command (FETCH) so the TokenParser is actually invoked.
+// ---------------------------------------------------------------------------
+
+const expectParserError = (input, code) => test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser(input);
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.equal(err.code, code);
+    });
+
+module.exports['Token Parser: E11: unexpected ] throws ParserError11'] = expectParserError('* 1 FETCH (])', 'ParserError11');
+module.exports['Token Parser: E12: ~ not followed by { throws ParserError12'] = expectParserError('* 1 FETCH ~%', 'ParserError12');
+module.exports['Token Parser: E16: \\* followed by char throws ParserError17'] = expectParserError('* 1 FETCH \\*x', 'ParserError17');
+module.exports['Token Parser: E19: partial ending with . throws ParserError19'] = expectParserError('* 1 FETCH BODY[]<0.>', 'ParserError19');
+module.exports['Token Parser: E20: partial leading . throws ParserError20'] = expectParserError('* 1 FETCH BODY[]<.>', 'ParserError20');
+module.exports['Token Parser: E21: non-digit in partial throws ParserError21'] = expectParserError('* 1 FETCH BODY[]<0.x>', 'ParserError21');
+module.exports['Token Parser: E22: invalid leading-zero partial throws ParserError22'] = expectParserError('* 1 FETCH BODY[]<00>', 'ParserError22');
+module.exports['Token Parser: E24: literal prefix not followed by CRLF throws ParserError24'] = expectParserError('* 1 FETCH {3}xyz', 'ParserError24');
+module.exports['Token Parser: E27: whitespace mid-sequence throws ParserError27'] = expectParserError('* 1 FETCH 1: 2', 'ParserError27');
+
+module.exports['Token Parser: bare * is normalized to an ATOM'] = test =>
+    asyncWrapper(test, async test => {
+        let r = await parser('* 1 FETCH *');
+        let last = r.attributes[r.attributes.length - 1];
+        test.equal(last.type, 'ATOM');
+        test.equal(last.value, '*');
+    });
+
+module.exports['Token Parser: ~ followed by atom chars becomes an ATOM'] = test =>
+    asyncWrapper(test, async test => {
+        let r = await parser('* 1 FETCH ~abc');
+        let last = r.attributes[r.attributes.length - 1];
+        test.equal(last.type, 'ATOM');
+        test.equal(last.value, '~abc');
+    });
+
+module.exports['Token Parser: E16: invalid char in atom throws ParserError16'] = expectParserError('* 1 FETCH 3* 4', 'ParserError16');
+
+module.exports['Token Parser: literal+ (non-synchronizing) marker is accepted'] = test =>
+    asyncWrapper(test, async test => {
+        // {3+} is a LITERAL+ prefix; with literalPlus enabled and no pre-parsed
+        // literals, the parser reads the literal bytes inline.
+        let r = await parser('* 1 FETCH {3+}\r\nabc', { literalPlus: true });
+        let lit = r.attributes[r.attributes.length - 1];
+        test.equal(lit.type, 'LITERAL');
+        test.equal(lit.value.toString(), 'abc');
+    });
+
+module.exports['Token Parser: literal prefix terminated by bare LF is accepted'] = test =>
+    asyncWrapper(test, async test => {
+        let r = await parser('* 1 FETCH {3}\nabc');
+        let lit = r.attributes[r.attributes.length - 1];
+        test.equal(lit.type, 'LITERAL');
+        test.equal(lit.value.toString(), 'abc');
+    });