imapflow 1.7.8 → 2.0.1

package/test/connection-test.js

@@ -1,162 +0,0 @@
-'use strict';
-
-const { ImapFlow } = require('../lib/imap-flow');
-
-module.exports['Connection: Basic connection options'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        port: 993,
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    test.equal(client.host, 'imap.example.com');
-    test.equal(client.port, 993);
-    test.done();
-};
-
-module.exports['Connection: Default options'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    test.equal(client.port, 143);
-    test.equal(client.secureConnection, false);
-    test.done();
-};
-
-module.exports['Connection: Secure connection defaults'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        port: 993,
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    test.equal(client.secureConnection, true);
-    test.done();
-};
-
-module.exports['Connection: TLS options'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' },
-        tls: {
-            rejectUnauthorized: false,
-            minVersion: 'TLSv1.3'
-        }
-    });
-
-    test.equal(client.options.tls.rejectUnauthorized, false);
-    test.equal(client.options.tls.minVersion, 'TLSv1.3');
-    test.done();
-};
-
-module.exports['Connection: Authentication options'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: {
-            user: 'testuser',
-            pass: 'testpass',
-            accessToken: 'token123'
-        }
-    });
-
-    test.equal(client.options.auth.user, 'testuser');
-    test.equal(client.options.auth.pass, 'testpass');
-    test.equal(client.options.auth.accessToken, 'token123');
-    test.done();
-};
-
-module.exports['Connection: Proxy configuration'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' },
-        proxy: 'socks5://proxy.example.com:1080'
-    });
-
-    test.equal(client.options.proxy, 'socks5://proxy.example.com:1080');
-    test.done();
-};
-
-module.exports['Connection: Client info'] = test => {
-    let clientInfo = {
-        name: 'Test Client',
-        version: '1.0.0',
-        vendor: 'Test Corp'
-    };
-
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' },
-        clientInfo
-    });
-
-    test.equal(client.clientInfo.name, 'Test Client');
-    test.equal(client.clientInfo.version, '1.0.0');
-    test.equal(client.clientInfo.vendor, 'Test Corp');
-    test.done();
-};
-
-module.exports['Connection: Logger configuration'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' },
-        logger: false
-    });
-
-    test.equal(client.options.logger, false);
-    test.done();
-};
-
-module.exports['Connection: Stats tracking'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    let stats = client.stats();
-    test.ok(Object.prototype.hasOwnProperty.call(stats, 'sent'));
-    test.ok(Object.prototype.hasOwnProperty.call(stats, 'received'));
-    test.equal(typeof stats.sent, 'number');
-    test.equal(typeof stats.received, 'number');
-    test.done();
-};
-
-module.exports['Connection: Random ID generation'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    let id1 = client.getRandomId();
-    let id2 = client.getRandomId();
-
-    test.ok(typeof id1 === 'string' && id1.length > 0);
-    test.ok(typeof id2 === 'string' && id2.length > 0);
-    test.notEqual(id1, id2, 'IDs should be unique');
-    test.done();
-};
-
-module.exports['Connection: State management'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    test.equal(client.state, client.states.NOT_AUTHENTICATED);
-    test.equal(client.authenticated, false);
-    test.ok(client.capabilities instanceof Map);
-    test.done();
-};
-
-module.exports['Connection: Event emitter setup'] = test => {
-    let client = new ImapFlow({
-        host: 'imap.example.com',
-        auth: { user: 'test', pass: 'test' }
-    });
-
-    test.equal(typeof client.on, 'function');
-    test.equal(typeof client.emit, 'function');
-    test.equal(typeof client.removeListener, 'function');
-    test.done();
-};

package/test/copyuid-parser-test.js

@@ -1,173 +0,0 @@
-'use strict';
-
-const { parseCopyUid } = require('../lib/commands/copyuid-parser');
-
-/**
- * Builds a minimal IMAP response object with a COPYUID-style section.
- *
- * @param {Array} section - Array of section elements with value properties
- * @returns {Object} Response object suitable for parseCopyUid
- */
-function makeResponse(section) {
-    return { attributes: [{ section }] };
-}
-
-// ============================================
-// Single UID pair
-// ============================================
-
-module.exports['CopyUID Parser: single UID pair sets uidValidity and uidMap entry'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '12345' }, { value: '1' }, { value: '100' }]), map);
-
-    test.equal(map.uidValidity, BigInt('12345'));
-    test.ok(map.uidMap instanceof Map);
-    test.equal(map.uidMap.get(1), 100);
-    test.equal(map.uidMap.size, 1);
-    test.done();
-};
-
-// ============================================
-// UID ranges
-// ============================================
-
-module.exports['CopyUID Parser: contiguous UID range maps all source UIDs to destinations'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '99' }, { value: '1:3' }, { value: '10:12' }]), map);
-
-    test.equal(map.uidValidity, BigInt('99'));
-    test.ok(map.uidMap instanceof Map);
-    test.equal(map.uidMap.size, 3);
-    test.equal(map.uidMap.get(1), 10);
-    test.equal(map.uidMap.get(2), 11);
-    test.equal(map.uidMap.get(3), 12);
-    test.done();
-};
-
-// ============================================
-// Comma-separated UIDs
-// ============================================
-
-module.exports['CopyUID Parser: comma-separated UIDs map each source to its destination'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '200' }, { value: '1,5,9' }, { value: '100,105,109' }]), map);
-
-    test.equal(map.uidMap.size, 3);
-    test.equal(map.uidMap.get(1), 100);
-    test.equal(map.uidMap.get(5), 105);
-    test.equal(map.uidMap.get(9), 109);
-    test.done();
-};
-
-// ============================================
-// Non-COPYUID response code
-// ============================================
-
-module.exports['CopyUID Parser: non-COPYUID response code leaves map unchanged'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'APPENDUID' }, { value: '12345' }, { value: '1' }, { value: '100' }]), map);
-
-    test.equal(map.uidValidity, undefined);
-    test.equal(map.uidMap, undefined);
-    test.done();
-};
-
-// ============================================
-// Missing / malformed input
-// ============================================
-
-module.exports['CopyUID Parser: missing attributes leaves map unchanged'] = test => {
-    let map = {};
-    parseCopyUid({}, map);
-
-    test.equal(map.uidValidity, undefined);
-    test.equal(map.uidMap, undefined);
-    test.done();
-};
-
-module.exports['CopyUID Parser: empty attributes array leaves map unchanged'] = test => {
-    let map = {};
-    parseCopyUid({ attributes: [] }, map);
-
-    test.equal(map.uidValidity, undefined);
-    test.equal(map.uidMap, undefined);
-    test.done();
-};
-
-module.exports['CopyUID Parser: null section leaves map unchanged'] = test => {
-    let map = {};
-    parseCopyUid({ attributes: [{ section: null }] }, map);
-
-    test.equal(map.uidValidity, undefined);
-    test.equal(map.uidMap, undefined);
-    test.done();
-};
-
-// ============================================
-// Non-numeric uidValidity
-// ============================================
-
-module.exports['CopyUID Parser: non-numeric uidValidity skips uidValidity but still builds uidMap'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: 'abc' }, { value: '1' }, { value: '100' }]), map);
-
-    test.equal(map.uidValidity, undefined);
-    test.ok(map.uidMap instanceof Map);
-    test.equal(map.uidMap.get(1), 100);
-    test.done();
-};
-
-// ============================================
-// Mismatched source/destination lengths
-// ============================================
-
-module.exports['CopyUID Parser: mismatched source and destination lengths sets uidValidity but skips uidMap'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '12345' }, { value: '1:3' }, { value: '10' }]), map);
-
-    test.equal(map.uidValidity, BigInt('12345'));
-    test.equal(map.uidMap, undefined);
-    test.done();
-};
-
-// ============================================
-// Large uidValidity
-// ============================================
-
-module.exports['CopyUID Parser: large uidValidity is stored as BigInt'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '999999999999' }, { value: '1' }, { value: '100' }]), map);
-
-    test.equal(map.uidValidity, BigInt('999999999999'));
-    test.done();
-};
-
-module.exports['CopyUID Parser: uidValidity zero is stored as BigInt(0)'] = test => {
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '0' }, { value: '1' }, { value: '100' }]), map);
-
-    test.strictEqual(map.uidValidity, BigInt(0));
-    test.ok(map.uidMap instanceof Map);
-    test.equal(map.uidMap.get(1), 100);
-    test.done();
-};
-
-// ============================================
-// Hostile server input
-// ============================================
-
-module.exports['CopyUID Parser: non-decimal uidValidity is ignored, uidMap still parsed'] = test => {
-    // isNaN() passed values like "1e5" and "Infinity" through, and BigInt() then threw,
-    // losing the whole COPYUID result
-    let map = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: '1e5' }, { value: '1' }, { value: '100' }]), map);
-    test.equal(map.uidValidity, undefined);
-    test.ok(map.uidMap instanceof Map);
-    test.equal(map.uidMap.get(1), 100);
-
-    let map2 = {};
-    parseCopyUid(makeResponse([{ value: 'COPYUID' }, { value: 'Infinity' }, { value: '1' }, { value: '100' }]), map2);
-    test.equal(map2.uidValidity, undefined);
-    test.equal(map2.uidMap.get(1), 100);
-    test.done();
-};

package/test/fetch-generator-test.js

@@ -1,218 +0,0 @@
-'use strict';
-
-const { ImapFlow } = require('../lib/imap-flow');
-
-// Helper: create a minimal mock context with the fetch() generator bound to it.
-// The `run` override controls how untagged FETCH responses are delivered.
-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
-});
-
-// Helper: invoke the fetch generator on a mock context
-function callFetch(ctx, range, query, options) {
-    return ImapFlow.prototype.fetch.call(ctx, range, query, options);
-}
-
-// Helper: create a mock `run` that delivers `count` untagged FETCH responses,
-// each with a `next` callback for backpressure. Returns a tracking object.
-function createMockRun(count) {
-    const tracker = {
-        nextCalls: [], // records which message indices had next() called
-        onUntaggedFetch: null,
-        runResolved: false
-    };
-
-    const run = async (_cmd, _range, _query, opts) => {
-        tracker.onUntaggedFetch = opts.onUntaggedFetch;
-
-        for (let i = 0; i < count; i++) {
-            await new Promise(resolve => {
-                opts.onUntaggedFetch({ seq: i + 1, uid: 100 + i }, () => {
-                    tracker.nextCalls.push(i);
-                    resolve();
-                });
-            });
-        }
-        tracker.runResolved = true;
-    };
-
-    return { tracker, run };
-}
-
-// ---------------------------------------------------------------------------
-// Test: early break releases backpressure
-// ---------------------------------------------------------------------------
-module.exports['fetch generator: early break releases backpressure'] = async test => {
-    const { tracker, run } = createMockRun(5);
-    const ctx = createFetchContext(run);
-
-    const gen = callFetch(ctx, '1:5', { uid: true });
-    // Consume only the first message and break
-    for await (let msg of gen) {
-        test.ok(msg.seq === 1, 'should receive the first message');
-        break;
-    }
-
-    // Allow microtasks to flush (the finally block runs synchronously with
-    // generator return, but the remaining run() deliveries are async)
-    await new Promise(r => setTimeout(r, 50));
-
-    // The first message had next() called by the yield loop (res.next()).
-    // Remaining queued/future messages should have next() called by the
-    // finally block or the aborted guard.
-    test.equal(tracker.nextCalls.length, 5, 'all 5 messages should have next() called');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// Test: subsequent operations work after early exit
-// ---------------------------------------------------------------------------
-module.exports['fetch generator: connection usable after early break'] = async test => {
-    let runCallCount = 0;
-
-    const run = async (_cmd, _range, _query, opts) => {
-        runCallCount++;
-        // Deliver 3 messages
-        for (let i = 0; i < 3; i++) {
-            await new Promise(resolve => {
-                opts.onUntaggedFetch({ seq: i + 1, uid: 200 + i }, () => resolve());
-            });
-        }
-    };
-
-    const ctx = createFetchContext(run);
-
-    // First fetch: break early
-    const gen1 = callFetch(ctx, '1:3', { uid: true });
-    for await (let msg of gen1) {
-        test.ok(msg.seq === 1);
-        break;
-    }
-
-    await new Promise(r => setTimeout(r, 50));
-
-    // Second fetch: should work (run gets called again)
-    const gen2 = callFetch(ctx, '1:3', { uid: true });
-    let secondFetchMessages = [];
-    for await (let msg of gen2) {
-        secondFetchMessages.push(msg);
-    }
-
-    test.ok(runCallCount === 2, 'run was called for both fetch operations');
-    test.ok(secondFetchMessages.length === 3, 'second fetch received all 3 messages');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// Test: normal full iteration works correctly
-// ---------------------------------------------------------------------------
-module.exports['fetch generator: normal full iteration receives all messages'] = async test => {
-    const { tracker, run } = createMockRun(4);
-    const ctx = createFetchContext(run);
-
-    let messages = [];
-    for await (let msg of callFetch(ctx, '1:4', { uid: true })) {
-        messages.push(msg);
-    }
-
-    test.equal(messages.length, 4, 'should receive all 4 messages');
-    test.equal(messages[0].seq, 1);
-    test.equal(messages[3].seq, 4);
-    test.equal(tracker.nextCalls.length, 4, 'all next() callbacks were called');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// Test: error thrown in loop body releases backpressure
-// ---------------------------------------------------------------------------
-module.exports['fetch generator: error in loop body releases backpressure'] = async test => {
-    const { tracker, run } = createMockRun(5);
-    const ctx = createFetchContext(run);
-
-    const gen = callFetch(ctx, '1:5', { uid: true });
-
-    let caught = false;
-    try {
-        for await (let msg of gen) {
-            if (msg.seq === 2) {
-                throw new Error('intentional test error');
-            }
-        }
-    } catch (err) {
-        caught = true;
-        test.equal(err.message, 'intentional test error');
-    }
-
-    await new Promise(r => setTimeout(r, 50));
-
-    test.ok(caught, 'error was caught');
-    // Messages 0 and 1 had next() called by the yield loop. The rest should
-    // be drained by the finally block or the aborted guard.
-    test.equal(tracker.nextCalls.length, 5, 'all 5 messages should have next() called');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// Test: zero messages from server
-// ---------------------------------------------------------------------------
-module.exports['fetch generator: zero messages yields nothing'] = async test => {
-    const { tracker, run } = createMockRun(0);
-    const ctx = createFetchContext(run);
-
-    let messages = [];
-    for await (let msg of callFetch(ctx, '1:*', { uid: true })) {
-        messages.push(msg);
-    }
-
-    test.equal(messages.length, 0, 'no messages should be yielded');
-    test.equal(tracker.nextCalls.length, 0, 'no next() calls needed');
-    test.ok(tracker.runResolved, 'run should have resolved');
-    test.done();
-};
-
-// ---------------------------------------------------------------------------
-// Test: connection closed during iteration throws and releases backpressure
-// ---------------------------------------------------------------------------
-module.exports['fetch generator: connection closed mid-iteration throws and cleans up'] = async test => {
-    const tracker = {
-        nextCalls: []
-    };
-
-    const run = async (_cmd, _range, _query, opts) => {
-        for (let i = 0; i < 3; i++) {
-            await new Promise(resolve => {
-                opts.onUntaggedFetch({ seq: i + 1, uid: 300 + i }, () => {
-                    tracker.nextCalls.push(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) {
-                // Simulate connection closing after first message
-                ctx.isClosed = true;
-            }
-        }
-    } catch (err) {
-        caught = true;
-        test.equal(err.code, 'EConnectionClosed', 'should throw EConnectionClosed');
-    }
-
-    await new Promise(r => setTimeout(r, 50));
-
-    test.ok(caught, 'error was caught');
-    test.equal(tracker.nextCalls.length, 3, 'all next() callbacks should be called for cleanup');
-    test.done();
-};

package/test/fixtures/fake-timers.js

@@ -1,115 +0,0 @@
-'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 };