imapflow 1.7.8 → 2.0.1

package/test/imap-stream-test.js

@@ -1,177 +0,0 @@
-/*eslint no-unused-expressions: 0, prefer-arrow-callback: 0 */
-
-'use strict';
-
-const { ImapStream } = require('../lib/handler/imap-stream');
-const { parser } = require('../lib/handler/imap-handler');
-
-module.exports['Full input'] = test => {
-    let input = Buffer.from(
-        `A CAPABILITY
-A LOGIN "aaa" "bbb"
-A APPEND INBOX {5}
-12345
-A LOGIN {5}
-12345 {11}
-12345678901 "another"
-A LOGOUT
-`.replace(/\r?\n/g, '\r\n')
-    );
-
-    let expecting = [
-        { command: 'A CAPABILITY', literals: [] },
-        { command: 'A LOGIN "aaa" "bbb"', literals: [] },
-        { command: 'A APPEND INBOX {5}\r\n', literals: ['12345'] },
-        { command: 'A LOGIN {5}\r\n {11}\r\n "another"', literals: ['12345', '12345678901'] },
-        { command: 'A LOGOUT', literals: [] }
-    ];
-
-    let stream = new ImapStream();
-
-    let reading = false;
-    let reader = async () => {
-        let cmd;
-        while ((cmd = stream.read()) !== null) {
-            test.deepEqual({ command: cmd.payload.toString(), literals: cmd.literals.map(literal => literal.toString()) }, expecting.shift());
-
-            let parsed = await parser(cmd.payload, { literals: cmd.literals });
-            console.log(parsed);
-            cmd.next();
-        }
-    };
-
-    stream.on('readable', () => {
-        if (!reading) {
-            reading = true;
-            reader()
-                .catch(err => console.error(err))
-                .finally(() => {
-                    reading = false;
-                });
-        }
-    });
-
-    stream.on('error', err => {
-        test.ifError(err);
-    });
-
-    stream.on('end', () => {
-        test.done();
-    });
-
-    let writer = async () => {
-        stream.end(input);
-    };
-
-    writer().catch(err => test.ifError(err));
-};
-
-module.exports['Literal8 marker activates literal extraction'] = test => {
-    // RFC 9051 folds the FETCH side of BINARY into base IMAP4rev2 - servers answer
-    // BINARY fetches with literal8 syntax (~{n}) whose content may contain NULs.
-    // The stream must treat the trailing {n} as a literal marker regardless of the
-    // '~' prefix and hand the raw bytes over unmodified.
-    let input = Buffer.from('* 1 FETCH (BINARY[1] ~{5}\r\nhel\x00o)\r\n', 'binary');
-
-    let stream = new ImapStream();
-
-    let reading = false;
-    let reader = async () => {
-        let cmd;
-        while ((cmd = stream.read()) !== null) {
-            test.equal(cmd.payload.toString('binary'), '* 1 FETCH (BINARY[1] ~{5}\r\n)');
-            test.equal(cmd.literals.length, 1);
-            test.deepEqual(cmd.literals[0], Buffer.from('hel\x00o', 'binary'));
-
-            // and the parser consumes the literal8 into a LITERAL node with the NUL intact
-            let parsed = await parser(cmd.payload, { literals: cmd.literals });
-            test.deepEqual(parsed.attributes[1][1], { type: 'LITERAL', value: Buffer.from('hel\x00o', 'binary') });
-            cmd.next();
-        }
-    };
-
-    stream.on('readable', () => {
-        if (!reading) {
-            reading = true;
-            reader()
-                .catch(err => test.ifError(err))
-                .finally(() => {
-                    reading = false;
-                });
-        }
-    });
-
-    stream.on('error', err => {
-        test.ifError(err);
-    });
-
-    stream.on('end', () => {
-        test.done();
-    });
-
-    stream.end(input);
-};
-
-module.exports['Single byte'] = test => {
-    let input = Buffer.from(
-        `A CAPABILITY
-A LOGIN "aaa" "bbb"
-A APPEND INBOX {5}
-12345
-A LOGIN {5}
-12345 {11}
-12345678901 "another"
-A LOGOUT
-`.replace(/\r?\n/g, '\r\n')
-    );
-
-    let expecting = [
-        { command: 'A CAPABILITY', literals: [] },
-        { command: 'A LOGIN "aaa" "bbb"', literals: [] },
-        { command: 'A APPEND INBOX {5}\r\n', literals: ['12345'] },
-        { command: 'A LOGIN {5}\r\n {11}\r\n "another"', literals: ['12345', '12345678901'] },
-        { command: 'A LOGOUT', literals: [] }
-    ];
-
-    let stream = new ImapStream();
-
-    let reading = false;
-    let reader = async () => {
-        let cmd;
-        while ((cmd = stream.read()) !== null) {
-            test.deepEqual({ command: cmd.payload.toString(), literals: cmd.literals.map(literal => literal.toString()) }, expecting.shift());
-            cmd.next();
-        }
-    };
-
-    stream.on('readable', () => {
-        if (!reading) {
-            reading = true;
-            reader()
-                .catch(err => console.error(err))
-                .finally(() => {
-                    reading = false;
-                });
-        }
-    });
-
-    stream.on('error', err => {
-        test.ifError(err);
-    });
-
-    stream.on('end', () => {
-        test.done();
-    });
-
-    let writer = async () => {
-        for (let i = 0; i < input.length; i++) {
-            if (stream.write(Buffer.from([input[i]])) === false) {
-                await new Promise(resolve => stream.once('drain', resolve));
-            }
-            await new Promise(resolve => setTimeout(resolve, 10));
-        }
-        stream.end();
-    };
-
-    writer().catch(err => test.ifError(err));
-};

package/test/imapflow-test.js

@@ -1,258 +0,0 @@
-'use strict';
-
-const { ImapFlow } = require('../lib/imap-flow');
-
-module.exports['Create imapflow instance'] = test => {
-    let imapFlow = new ImapFlow();
-    test.ok(imapFlow);
-    test.done();
-};
-
-module.exports['Create imapflow instance with custom logger'] = async test => {
-    class CustomLogger {
-        constructor() {}
-
-        debug(obj) {
-            console.log(JSON.stringify(obj));
-        }
-
-        info(obj) {
-            console.log(JSON.stringify(obj));
-        }
-
-        warn(obj) {
-            console.log(JSON.stringify(obj));
-        }
-
-        // eslint-disable-next-line no-unused-vars
-        error(obj) {
-            // we don't actually want to log anything here.
-        }
-    }
-
-    let imapFlow = new ImapFlow({
-        logger: new CustomLogger()
-    });
-    test.ok(imapFlow);
-    try {
-        await imapFlow.connect();
-    } catch (ex) {
-        // it is PERFECTLY okay to have an exception here. We expect an ECONNREFUSED if an exception occurs.
-        test.equal(ex.code, 'ECONNREFUSED');
-    }
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// Helpers for testing prototype methods on a mock context
-// ---------------------------------------------------------------------------
-const createFetchContext = runOverride => ({
-    id: 'test-cid',
-    mailbox: { path: 'INBOX', exists: 10 },
-    isClosed: false,
-    socket: { destroyed: false },
-    resolveRange: async range => range,
-    createConnectionError: ImapFlow.prototype.createConnectionError,
-    run: runOverride
-});
-
-function callFetch(ctx, range, query, options) {
-    return ImapFlow.prototype.fetch.call(ctx, range, query, options);
-}
-
-// ---------------------------------------------------------------------------
-// setFlagColor tests
-// ---------------------------------------------------------------------------
-
-module.exports['setFlagColor with valid color calls STORE for add and remove'] = async test => {
-    let storeCalls = [];
-    const ctx = {
-        resolveRange: async range => range,
-        run: async (command, range, flags, opts) => {
-            storeCalls.push({ command, range, flags, operation: opts.operation });
-            return true;
-        }
-    };
-
-    let result = await ImapFlow.prototype.setFlagColor.call(ctx, '1:*', 'orange');
-
-    test.equal(storeCalls.length, 2, 'run should be called twice');
-
-    test.equal(storeCalls[0].command, 'STORE');
-    test.equal(storeCalls[0].operation, 'add');
-    test.ok(storeCalls[0].flags.indexOf('\\Flagged') >= 0, 'add flags should include \\Flagged');
-    test.ok(storeCalls[0].flags.indexOf('$MailFlagBit0') >= 0, 'add flags should include $MailFlagBit0');
-
-    test.equal(storeCalls[1].command, 'STORE');
-    test.equal(storeCalls[1].operation, 'remove');
-    test.ok(storeCalls[1].flags.indexOf('$MailFlagBit1') >= 0, 'remove flags should include $MailFlagBit1');
-    test.ok(storeCalls[1].flags.indexOf('$MailFlagBit2') >= 0, 'remove flags should include $MailFlagBit2');
-
-    test.ok(result, 'should return truthy result');
-    test.done();
-};
-
-module.exports['setFlagColor with invalid color returns false'] = async test => {
-    let runCalled = false;
-    const ctx = {
-        resolveRange: async range => range,
-        run: async () => {
-            runCalled = true;
-        }
-    };
-
-    let result = await ImapFlow.prototype.setFlagColor.call(ctx, '1:*', 'invalid');
-
-    test.strictEqual(result, false, 'should return false for invalid color');
-    test.ok(!runCalled, 'run should not be called');
-    test.done();
-};
-
-module.exports['setFlagColor with empty range returns false'] = async test => {
-    let runCalled = false;
-    const ctx = {
-        resolveRange: async () => null,
-        run: async () => {
-            runCalled = true;
-        }
-    };
-
-    let result = await ImapFlow.prototype.setFlagColor.call(ctx, '1:*', 'orange');
-
-    test.strictEqual(result, false, 'should return false for empty range');
-    test.ok(!runCalled, 'run should not be called');
-    test.done();
-};
-
-module.exports['setFlagColor with red calls STORE with Flagged in add'] = async test => {
-    let storeCalls = [];
-    const ctx = {
-        resolveRange: async range => range,
-        run: async (command, range, flags, opts) => {
-            storeCalls.push({ command, range, flags, operation: opts.operation });
-            return true;
-        }
-    };
-
-    let result = await ImapFlow.prototype.setFlagColor.call(ctx, '1:*', 'red');
-
-    // red is index 0 (all bits zero), so add should contain only \Flagged,
-    // and remove should contain all three MailFlagBit flags
-    test.ok(storeCalls.length >= 1, 'run should be called at least once');
-
-    let addCall = storeCalls.find(c => c.operation === 'add');
-    test.ok(addCall, 'should have an add operation');
-    test.ok(addCall.flags.indexOf('\\Flagged') >= 0, 'add flags should include \\Flagged for red');
-
-    let removeCall = storeCalls.find(c => c.operation === 'remove');
-    test.ok(removeCall, 'should have a remove operation');
-    test.ok(removeCall.flags.indexOf('$MailFlagBit0') >= 0, 'remove flags should include $MailFlagBit0');
-    test.ok(removeCall.flags.indexOf('$MailFlagBit1') >= 0, 'remove flags should include $MailFlagBit1');
-    test.ok(removeCall.flags.indexOf('$MailFlagBit2') >= 0, 'remove flags should include $MailFlagBit2');
-
-    test.ok(result, 'should return truthy result');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// status test
-// ---------------------------------------------------------------------------
-
-module.exports['status delegates to run with STATUS command'] = async test => {
-    let runArgs = null;
-    const ctx = {
-        run: async (...args) => {
-            runArgs = args;
-            return { messages: 10, unseen: 3 };
-        }
-    };
-
-    let result = await ImapFlow.prototype.status.call(ctx, 'INBOX', { unseen: true });
-
-    test.deepEqual(runArgs, ['STATUS', 'INBOX', { unseen: true }], 'run should be called with correct arguments');
-    test.deepEqual(result, { messages: 10, unseen: 3 }, 'should return the result from run');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// getQuota tests
-// ---------------------------------------------------------------------------
-
-module.exports['getQuota delegates to run with QUOTA command'] = async test => {
-    let runArgs = null;
-    const ctx = {
-        run: async (...args) => {
-            runArgs = args;
-            return { storage: { usage: 1024, limit: 10240 } };
-        }
-    };
-
-    let result = await ImapFlow.prototype.getQuota.call(ctx, 'Sent');
-
-    test.deepEqual(runArgs, ['QUOTA', 'Sent'], 'run should be called with correct arguments');
-    test.ok(result.storage, 'should return quota result');
-    test.done();
-};
-
-module.exports['getQuota defaults path to INBOX'] = async test => {
-    let runArgs = null;
-    const ctx = {
-        run: async (...args) => {
-            runArgs = args;
-            return { storage: { usage: 512, limit: 10240 } };
-        }
-    };
-
-    let result = await ImapFlow.prototype.getQuota.call(ctx);
-
-    test.deepEqual(runArgs, ['QUOTA', 'INBOX'], 'run should be called with INBOX as default path');
-    test.ok(result.storage, 'should return quota result');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// fetch generator: error propagation tests
-// ---------------------------------------------------------------------------
-
-module.exports['fetch generator: run error propagates to consumer'] = async test => {
-    const run = async () => {
-        throw new Error('FETCH failed');
-    };
-    const ctx = createFetchContext(run);
-    let caught = false;
-    try {
-        // eslint-disable-next-line no-unused-vars
-        for await (let msg of callFetch(ctx, '1:5', { uid: true })) {
-            // should not reach here
-        }
-    } catch (err) {
-        caught = true;
-        test.equal(err.message, 'FETCH failed');
-    }
-    test.ok(caught, 'error was caught');
-    test.done();
-};
-
-module.exports['fetch generator: socket destroyed mid-iteration throws EConnectionClosed'] = async test => {
-    const run = async (cmd, range, query, opts) => {
-        for (let i = 0; i < 3; i++) {
-            await new Promise(resolve => {
-                opts.onUntaggedFetch({ seq: i + 1, uid: 400 + i }, () => resolve());
-            });
-        }
-    };
-    const ctx = createFetchContext(run);
-    let caught = false;
-    try {
-        for await (let msg of callFetch(ctx, '1:3', { uid: true })) {
-            if (msg.seq === 1) {
-                ctx.socket.destroyed = true;
-            }
-        }
-    } catch (err) {
-        caught = true;
-        test.equal(err.code, 'EConnectionClosed');
-    }
-    test.ok(caught, 'error was caught');
-    test.done();
-};

package/test/integration/README.md

@@ -1,52 +0,0 @@
-# Live IMAP4rev2 integration tests
-
-Runs the ImapFlow client against a real IMAP4rev2 server - Dovecot 2.4+ in
-Docker - instead of protocol mocks. Covers the ENABLE IMAP4rev2 negotiation,
-LIST RETURN (SUBSCRIBED) without LSUB, subscription round-trips, UTF-8 mailbox
-names, inline LIST-STATUS (including the rev2 SIZE and DELETED status items),
-ESEARCH responses to plain SEARCH, STATUS SIZE/DELETED, the rev2-shaped SELECT
-response (untagged LIST, CLOSED on re-select), the folded-in FETCH BINARY,
-COPYUID from the untagged OK on MOVE, and a message lifecycle smoke test with
-UID EXPUNGE.
-
-## Running
-
-```
-npm run test:rev2
-```
-
-Requires Docker. The script pulls `dovecot/dovecot:2.4.4`, starts a container
-with the drop-in config from `dovecot-test.conf`, waits for the IMAP greeting
-on `127.0.0.1:31143`, runs `rev2-live-test.js` with nodeunit, and always
-removes the container afterwards.
-
-These tests are intentionally not part of `npm test` - the Gruntfile nodeunit
-config excludes `test/integration/**`, so plain test runs stay Docker-free.
-CI runs this suite in a dedicated `test-rev2` job on `ubuntu-latest` (amd64
-with Docker preinstalled), forcing `IMAPFLOW_DOVECOT_PLATFORM=linux/amd64` -
-that job is the authoritative linux/amd64 run, since Apple Silicon machines
-cannot execute the amd64 image (see below).
-
-If a local image for the configured tag exists but was pulled for a different
-architecture than the Docker host (e.g. an amd64 image left behind on an arm64
-host), the runner script detects the mismatch and re-pulls the host-native
-variant before starting the container.
-
-## Environment overrides
-
-- `IMAPFLOW_DOVECOT_IMAGE` - image to run (default `dovecot/dovecot:2.4.4`;
-  any 2.4.2+ tag supports IMAP4rev2)
-- `IMAPFLOW_DOVECOT_PLATFORM` - e.g. `linux/amd64`; defaults to the host
-  platform. Forcing `linux/amd64` on Apple Silicon does not work - Rosetta
-  cannot start Dovecot's privilege-separated login processes
-  (`rosetta error: mmap_anonymous_rw mmap failed`; reconfirmed with
-  dovecot/dovecot:2.4.4 in July 2026)
-- `IMAPFLOW_TEST_PORT` - host port to publish (default 31143)
-
-## Test account model
-
-The container uses Dovecot's static passdb (`USER_PASSWORD=pass`): any
-username authenticates with the password `pass` and gets its own empty mail
-home, so every test connects as a brand-new user and needs no cleanup between
-runs. Special-use mailboxes (Sent/Drafts/Junk/Trash) are auto-created and
-subscribed via `dovecot-test.conf`.

package/test/integration/dovecot-test.conf

@@ -1,27 +0,0 @@
-# Drop-in configuration for the ImapFlow IMAP4rev2 integration test container.
-# Mounted into /etc/dovecot/conf.d/ of the dovecot/dovecot:2.4.x image, which
-# already ships with imap4rev2_enable = yes and mail_utf8_extensions = yes.
-
-# The test client connects over plain TCP on the container-internal IMAP port
-# (31143), so cleartext logins must be allowed
-auth_allow_cleartext = yes
-
-# Special-use mailboxes, auto-created and subscribed for every test user
-namespace inbox {
-  mailbox Sent {
-    special_use = \Sent
-    auto = subscribe
-  }
-  mailbox Drafts {
-    special_use = \Drafts
-    auto = subscribe
-  }
-  mailbox Junk {
-    special_use = \Junk
-    auto = subscribe
-  }
-  mailbox Trash {
-    special_use = \Trash
-    auto = subscribe
-  }
-}