imapflow 1.2.13 → 1.2.14

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

@@ -0,0 +1,275 @@
+/* eslint new-cap: 0 */
+'use strict';
+
+const imapFormalSyntax = require('../lib/handler/imap-formal-syntax');
+
+// ---------------------------------------------------------------------------
+// CHAR
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: CHAR() has length 127'] = test => {
+    test.equal(imapFormalSyntax.CHAR().length, 127);
+    test.done();
+};
+
+module.exports['Formal Syntax: CHAR() includes A'] = test => {
+    test.ok(imapFormalSyntax.CHAR().includes('A'));
+    test.done();
+};
+
+module.exports['Formal Syntax: CHAR() excludes NUL (0x00)'] = test => {
+    test.ok(!imapFormalSyntax.CHAR().includes('\x00'));
+    test.done();
+};
+
+module.exports['Formal Syntax: CHAR() excludes 0x80'] = test => {
+    test.ok(!imapFormalSyntax.CHAR().includes('\x80'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// CHAR8
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: CHAR8() has length 255'] = test => {
+    test.equal(imapFormalSyntax.CHAR8().length, 255);
+    test.done();
+};
+
+module.exports['Formal Syntax: CHAR8() includes 0xFF'] = test => {
+    test.ok(imapFormalSyntax.CHAR8().includes('\xFF'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// SP
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: SP() equals a single space'] = test => {
+    test.equal(imapFormalSyntax.SP(), ' ');
+    test.done();
+};
+
+module.exports['Formal Syntax: SP() has length 1'] = test => {
+    test.equal(imapFormalSyntax.SP().length, 1);
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// CTL
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: CTL() includes NUL (0x00)'] = test => {
+    test.ok(imapFormalSyntax.CTL().includes('\x00'));
+    test.done();
+};
+
+module.exports['Formal Syntax: CTL() includes 0x1F'] = test => {
+    test.ok(imapFormalSyntax.CTL().includes('\x1F'));
+    test.done();
+};
+
+module.exports['Formal Syntax: CTL() includes DEL (0x7F)'] = test => {
+    test.ok(imapFormalSyntax.CTL().includes('\x7F'));
+    test.done();
+};
+
+module.exports['Formal Syntax: CTL() excludes space (0x20)'] = test => {
+    test.ok(!imapFormalSyntax.CTL().includes(' '));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// ALPHA
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: ALPHA() has length 52'] = test => {
+    test.equal(imapFormalSyntax.ALPHA().length, 52);
+    test.done();
+};
+
+module.exports['Formal Syntax: ALPHA() includes A'] = test => {
+    test.ok(imapFormalSyntax.ALPHA().includes('A'));
+    test.done();
+};
+
+module.exports['Formal Syntax: ALPHA() includes z'] = test => {
+    test.ok(imapFormalSyntax.ALPHA().includes('z'));
+    test.done();
+};
+
+module.exports['Formal Syntax: ALPHA() excludes 0'] = test => {
+    test.ok(!imapFormalSyntax.ALPHA().includes('0'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// DIGIT
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: DIGIT() has length 10'] = test => {
+    test.equal(imapFormalSyntax.DIGIT().length, 10);
+    test.done();
+};
+
+module.exports['Formal Syntax: DIGIT() includes 0'] = test => {
+    test.ok(imapFormalSyntax.DIGIT().includes('0'));
+    test.done();
+};
+
+module.exports['Formal Syntax: DIGIT() includes 9'] = test => {
+    test.ok(imapFormalSyntax.DIGIT().includes('9'));
+    test.done();
+};
+
+module.exports['Formal Syntax: DIGIT() excludes a'] = test => {
+    test.ok(!imapFormalSyntax.DIGIT().includes('a'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// ATOM-CHAR
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: ATOM-CHAR() includes A'] = test => {
+    test.ok(imapFormalSyntax['ATOM-CHAR']().includes('A'));
+    test.done();
+};
+
+module.exports['Formal Syntax: ATOM-CHAR() excludes open paren'] = test => {
+    test.ok(!imapFormalSyntax['ATOM-CHAR']().includes('('));
+    test.done();
+};
+
+module.exports['Formal Syntax: ATOM-CHAR() excludes close paren'] = test => {
+    test.ok(!imapFormalSyntax['ATOM-CHAR']().includes(')'));
+    test.done();
+};
+
+module.exports['Formal Syntax: ATOM-CHAR() excludes open brace'] = test => {
+    test.ok(!imapFormalSyntax['ATOM-CHAR']().includes('{'));
+    test.done();
+};
+
+module.exports['Formal Syntax: ATOM-CHAR() excludes space'] = test => {
+    test.ok(!imapFormalSyntax['ATOM-CHAR']().includes(' '));
+    test.done();
+};
+
+module.exports['Formal Syntax: ATOM-CHAR() excludes double quote'] = test => {
+    test.ok(!imapFormalSyntax['ATOM-CHAR']().includes('"'));
+    test.done();
+};
+
+module.exports['Formal Syntax: ATOM-CHAR() excludes backslash'] = test => {
+    test.ok(!imapFormalSyntax['ATOM-CHAR']().includes('\\'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// ASTRING-CHAR
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: ASTRING-CHAR() includes close bracket (resp-special)'] = test => {
+    test.ok(imapFormalSyntax['ASTRING-CHAR']().includes(']'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// TEXT-CHAR
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: TEXT-CHAR() includes A'] = test => {
+    test.ok(imapFormalSyntax['TEXT-CHAR']().includes('A'));
+    test.done();
+};
+
+module.exports['Formal Syntax: TEXT-CHAR() includes space'] = test => {
+    test.ok(imapFormalSyntax['TEXT-CHAR']().includes(' '));
+    test.done();
+};
+
+module.exports['Formal Syntax: TEXT-CHAR() excludes CR'] = test => {
+    test.ok(!imapFormalSyntax['TEXT-CHAR']().includes('\r'));
+    test.done();
+};
+
+module.exports['Formal Syntax: TEXT-CHAR() excludes LF'] = test => {
+    test.ok(!imapFormalSyntax['TEXT-CHAR']().includes('\n'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// tag
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: tag() excludes plus sign'] = test => {
+    test.ok(!imapFormalSyntax.tag().includes('+'));
+    test.done();
+};
+
+module.exports['Formal Syntax: tag() includes A'] = test => {
+    test.ok(imapFormalSyntax.tag().includes('A'));
+    test.done();
+};
+
+module.exports['Formal Syntax: tag() includes close bracket'] = test => {
+    test.ok(imapFormalSyntax.tag().includes(']'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// command
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: command() includes A'] = test => {
+    test.ok(imapFormalSyntax.command().includes('A'));
+    test.done();
+};
+
+module.exports['Formal Syntax: command() includes 0'] = test => {
+    test.ok(imapFormalSyntax.command().includes('0'));
+    test.done();
+};
+
+module.exports['Formal Syntax: command() includes hyphen'] = test => {
+    test.ok(imapFormalSyntax.command().includes('-'));
+    test.done();
+};
+
+module.exports['Formal Syntax: command() excludes asterisk'] = test => {
+    test.ok(!imapFormalSyntax.command().includes('*'));
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// verify()
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: verify() returns -1 when all characters are valid'] = test => {
+    test.equal(imapFormalSyntax.verify('ABC', 'ABCDEF'), -1);
+    test.done();
+};
+
+module.exports['Formal Syntax: verify() returns index of first invalid character'] = test => {
+    test.equal(imapFormalSyntax.verify('ABXC', 'ABC'), 2);
+    test.done();
+};
+
+module.exports['Formal Syntax: verify() returns 0 when first character is invalid'] = test => {
+    test.equal(imapFormalSyntax.verify('!A', 'ABC'), 0);
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Memoization
+// ---------------------------------------------------------------------------
+
+module.exports['Formal Syntax: CHAR() returns same string reference on repeated calls (memoized)'] = test => {
+    // After the first call, the method is replaced with a closure that returns
+    // the cached value, so subsequent calls must return the exact same string object.
+    const first = imapFormalSyntax.CHAR();
+    const second = imapFormalSyntax.CHAR();
+    test.strictEqual(first, second);
+    test.done();
+};

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

@@ -0,0 +1,268 @@
+/*eslint no-unused-expressions: 0, prefer-arrow-callback: 0 */
+
+'use strict';
+
+const { ImapStream } = require('../lib/handler/imap-stream');
+
+/**
+ * Helper that wires up the standard readable/next consumer pattern used across tests.
+ *
+ * The reader calls onCommand synchronously for each command object, then calls cmd.next()
+ * to allow the stream to continue. test.done() is called on the 'end' event.
+ *
+ * The readable handler uses a pendingRead flag so that if a 'readable' event fires
+ * while the reader is active, a follow-up read is triggered after the reader finishes.
+ * This prevents the 'end' event from being missed when the stream ends between reader
+ * iterations.
+ *
+ * @param {Object} test - nodeunit test object
+ * @param {Function} onCommand - synchronous function(cmd) called for each parsed command
+ * @param {Function} writer - async function(stream) that writes data to the stream
+ * @param {number} [expectedCount] - if set, assert that exactly this many commands were emitted
+ */
+function runStreamTest(test, onCommand, writer, expectedCount) {
+    const stream = new ImapStream({ cid: 'test' });
+    let commandCount = 0;
+
+    let reading = false;
+    let pendingRead = false;
+
+    const reader = async () => {
+        let cmd;
+        while ((cmd = stream.read()) !== null) {
+            commandCount++;
+            onCommand(cmd);
+            cmd.next();
+        }
+    };
+
+    const drainStream = () => {
+        if (reading) {
+            pendingRead = true;
+            return;
+        }
+        reading = true;
+        reader()
+            .catch(err => test.ifError(err))
+            .finally(() => {
+                reading = false;
+                if (pendingRead) {
+                    pendingRead = false;
+                    drainStream();
+                }
+            });
+    };
+
+    stream.on('readable', drainStream);
+
+    stream.on('error', err => {
+        test.ifError(err);
+    });
+
+    stream.on('end', () => {
+        if (expectedCount !== undefined) {
+            test.equal(commandCount, expectedCount, `expected ${expectedCount} command(s), got ${commandCount}`);
+        }
+        test.done();
+    });
+
+    writer(stream).catch(err => test.ifError(err));
+}
+
+module.exports['Literal split across chunks'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), 'A APPEND {5}\r\n', 'payload should include literal marker line');
+            test.equal(cmd.literals.length, 1, 'should have one literal');
+            test.ok(Buffer.isBuffer(cmd.literals[0]), 'literal should be a Buffer');
+            test.equal(cmd.literals[0].toString(), '12345', 'literal content should be 12345');
+        },
+        async stream => {
+            stream.write(Buffer.from('A APPEND {5}\r\n'));
+            stream.end(Buffer.from('12345\r\n'));
+        },
+        1
+    );
+};
+
+module.exports['Literal with zero size'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), 'A APPEND {0}\r\n', 'payload should include zero-size literal marker');
+            test.equal(cmd.literals.length, 1, 'should have one literal');
+            test.ok(Buffer.isBuffer(cmd.literals[0]), 'literal should be a Buffer');
+            test.equal(cmd.literals[0].length, 0, 'literal should be empty (length 0)');
+        },
+        async stream => {
+            stream.end(Buffer.from('A APPEND {0}\r\n\r\n'));
+        },
+        1
+    );
+};
+
+module.exports['Multiple commands in single chunk'] = test => {
+    const expected = ['A CMD1', 'B CMD2'];
+    let index = 0;
+
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), expected[index], `command ${index} payload`);
+            index++;
+        },
+        async stream => {
+            stream.end(Buffer.from('A CMD1\r\nB CMD2\r\n'));
+        },
+        2
+    );
+};
+
+module.exports['LiteralTooLarge error'] = test => {
+    const stream = new ImapStream({ cid: 'test' });
+
+    stream.on('error', err => {
+        test.equal(err.code, 'LiteralTooLarge', 'error code should be LiteralTooLarge');
+        stream.destroy();
+        test.done();
+    });
+
+    stream.write(Buffer.from('A APPEND {1073741825}\r\n'));
+};
+
+module.exports['Incomplete line continued in next chunk'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), 'A CAPABILITY', 'payload should be A CAPABILITY');
+            test.equal(cmd.literals.length, 0, 'should have no literals');
+        },
+        async stream => {
+            stream.write(Buffer.from('A CA'));
+            stream.end(Buffer.from('PABILITY\r\n'));
+        },
+        1
+    );
+};
+
+module.exports['Empty chunk then valid command'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), 'A CMD', 'payload should be A CMD');
+            test.equal(cmd.literals.length, 0, 'should have no literals');
+        },
+        async stream => {
+            stream.write(Buffer.alloc(0));
+            stream.end(Buffer.from('A CMD\r\n'));
+        },
+        1
+    );
+};
+
+module.exports['String input converted to Buffer'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), 'A CMD', 'payload should be A CMD');
+            test.ok(Buffer.isBuffer(cmd.payload), 'payload should be a Buffer');
+            test.equal(cmd.literals.length, 0, 'should have no literals');
+        },
+        async stream => {
+            stream.end('A CMD\r\n');
+        },
+        1
+    );
+};
+
+module.exports['LF-only line terminator'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.payload.toString(), 'A CMD', 'payload should be A CMD without CR or LF');
+            test.equal(cmd.literals.length, 0, 'should have no literals');
+        },
+        async stream => {
+            stream.end(Buffer.from('A CMD\n'));
+        },
+        1
+    );
+};
+
+module.exports['Many chunks trigger event loop yield'] = test => {
+    runStreamTest(
+        test,
+        cmd => {
+            // Just verify each command is valid
+            test.ok(cmd.payload.toString().startsWith('A'), 'command should start with tag');
+        },
+        async stream => {
+            for (let i = 0; i < 15; i++) {
+                stream.write(Buffer.from(`A CMD${i}\r\n`));
+            }
+            stream.end();
+        },
+        15
+    );
+};
+
+module.exports['Destroy with queued items does not hang'] = test => {
+    const stream = new ImapStream({ cid: 'test' });
+    let errorEmitted = false;
+
+    stream.on('error', () => {
+        errorEmitted = true;
+    });
+
+    // Write multiple chunks rapidly then destroy
+    stream.write(Buffer.from('A CMD1\r\n'));
+    stream.write(Buffer.from('B CMD2\r\n'));
+    stream.destroy();
+
+    // Errors from destroy are emitted synchronously or on next tick
+    setImmediate(() => {
+        test.ok(!errorEmitted, 'should not emit error on destroy');
+        test.done();
+    });
+};
+
+module.exports['logRaw option triggers trace logging'] = test => {
+    let traceCalled = false;
+    let traceData = null;
+
+    const stream = new ImapStream({
+        cid: 'test',
+        logRaw: true
+    });
+
+    // Override the log object to capture trace calls
+    stream.log = {
+        trace: data => {
+            traceCalled = true;
+            traceData = data;
+        },
+        debug: () => {},
+        info: () => {},
+        warn: () => {},
+        error: () => {}
+    };
+
+    // Also need to handle readable events
+    stream.on('readable', () => {
+        let cmd;
+        while ((cmd = stream.read()) !== null) {
+            cmd.next();
+        }
+    });
+
+    stream.on('end', () => {
+        test.ok(traceCalled, 'trace should have been called');
+        test.ok(traceData, 'trace data should exist');
+        test.equal(traceData.src, 's', 'source should be s');
+        test.ok(traceData.data, 'should have base64 data');
+        test.done();
+    });
+
+    stream.end(Buffer.from('A CMD\r\n'));
+};