imapflow 1.2.3 → 1.2.5

package/test/jp-decoder-test.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const { JPDecoder } = require('../lib/jp-decoder');
+const { PassThrough, Transform } = require('stream');
+
+// Helper to collect stream output
+const collectStream = stream =>
+    new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', chunk => chunks.push(chunk));
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+        stream.on('error', reject);
+    });
+
+// ============================================
+// Constructor tests
+// ============================================
+
+module.exports['JPDecoder: constructor sets charset'] = test => {
+    let decoder = new JPDecoder('iso-2022-jp');
+    test.equal(decoder.charset, 'iso-2022-jp');
+    test.deepEqual(decoder.chunks, []);
+    test.equal(decoder.chunklen, 0);
+    test.done();
+};
+
+module.exports['JPDecoder: is a Transform stream'] = test => {
+    let decoder = new JPDecoder('iso-2022-jp');
+    test.ok(decoder instanceof Transform);
+    test.ok(typeof decoder.pipe === 'function');
+    test.ok(typeof decoder.write === 'function');
+    test.done();
+};
+
+// ============================================
+// _transform tests
+// ============================================
+
+module.exports['JPDecoder: _transform accumulates buffer chunks'] = test => {
+    let decoder = new JPDecoder('iso-2022-jp');
+    let chunk1 = Buffer.from('hello');
+    let chunk2 = Buffer.from('world');
+
+    decoder._transform(chunk1, 'buffer', () => {
+        test.equal(decoder.chunks.length, 1);
+        test.equal(decoder.chunklen, 5);
+
+        decoder._transform(chunk2, 'buffer', () => {
+            test.equal(decoder.chunks.length, 2);
+            test.equal(decoder.chunklen, 10);
+            test.done();
+        });
+    });
+};
+
+module.exports['JPDecoder: _transform converts string to buffer'] = test => {
+    let decoder = new JPDecoder('iso-2022-jp');
+    let stringChunk = 'hello';
+
+    decoder._transform(stringChunk, 'utf8', () => {
+        test.equal(decoder.chunks.length, 1);
+        test.ok(Buffer.isBuffer(decoder.chunks[0]));
+        test.equal(decoder.chunks[0].toString(), 'hello');
+        test.done();
+    });
+};
+
+// ============================================
+// _flush tests
+// ============================================
+
+module.exports['JPDecoder: _flush outputs accumulated data'] = async test => {
+    let decoder = new JPDecoder('utf-8');
+    let output = collectStream(decoder);
+
+    decoder.write(Buffer.from('hello '));
+    decoder.write(Buffer.from('world'));
+    decoder.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello world');
+    test.done();
+};
+
+module.exports['JPDecoder: _flush converts ISO-2022-JP to Unicode'] = async test => {
+    let decoder = new JPDecoder('iso-2022-jp');
+    let output = collectStream(decoder);
+
+    // ISO-2022-JP encoded Japanese text for "nihongo" (Japanese)
+    // ESC $ B sequence switches to JIS X 0208, ESC ( B switches back to ASCII
+    let iso2022jp = Buffer.from([
+        0x1b,
+        0x24,
+        0x42, // ESC $ B - switch to JIS X 0208
+        0x46,
+        0x7c, // ni
+        0x4b,
+        0x5c, // hon
+        0x38,
+        0x6c, // go
+        0x1b,
+        0x28,
+        0x42 // ESC ( B - switch back to ASCII
+    ]);
+
+    decoder.write(iso2022jp);
+    decoder.end();
+
+    let result = await output;
+    test.ok(result.length > 0);
+    test.done();
+};
+
+module.exports['JPDecoder: _flush handles conversion errors gracefully'] = async test => {
+    // Use an invalid/unknown charset to trigger error path
+    let decoder = new JPDecoder('invalid-charset-xyz');
+    let output = collectStream(decoder);
+
+    let input = Buffer.from('test data');
+    decoder.write(input);
+    decoder.end();
+
+    let result = await output;
+    // On error, should return original input
+    test.equal(result.toString(), 'test data');
+    test.done();
+};
+
+module.exports['JPDecoder: _flush handles empty input'] = async test => {
+    let decoder = new JPDecoder('iso-2022-jp');
+    let output = collectStream(decoder);
+
+    decoder.end();
+
+    let result = await output;
+    test.equal(result.length, 0);
+    test.done();
+};
+
+// ============================================
+// Integration tests
+// ============================================
+
+module.exports['JPDecoder: works with pipe'] = async test => {
+    let source = new PassThrough();
+    let decoder = new JPDecoder('utf-8');
+    let output = collectStream(source.pipe(decoder));
+
+    source.write('hello ');
+    source.write('world');
+    source.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello world');
+    test.done();
+};
+
+module.exports['JPDecoder: handles multiple small chunks'] = async test => {
+    let decoder = new JPDecoder('utf-8');
+    let output = collectStream(decoder);
+
+    // Write character by character
+    'hello'.split('').forEach(char => decoder.write(char));
+    decoder.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello');
+    test.done();
+};
+
+module.exports['JPDecoder: handles Shift_JIS charset'] = async test => {
+    let decoder = new JPDecoder('shift_jis');
+    let output = collectStream(decoder);
+
+    // Shift_JIS encoded "test" in katakana (tesuto)
+    let shiftJis = Buffer.from([0x83, 0x65, 0x83, 0x58, 0x83, 0x67]);
+
+    decoder.write(shiftJis);
+    decoder.end();
+
+    let result = await output;
+    test.ok(result.length > 0);
+    test.done();
+};
+
+module.exports['JPDecoder: handles EUC-JP charset'] = async test => {
+    let decoder = new JPDecoder('euc-jp');
+    let output = collectStream(decoder);
+
+    // EUC-JP encoded Japanese character
+    let eucJp = Buffer.from([0xc6, 0xfc, 0xcb, 0xdc]); // nihon
+
+    decoder.write(eucJp);
+    decoder.end();
+
+    let result = await output;
+    test.ok(result.length > 0);
+    test.done();
+};

package/test/limited-passthrough-test.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const { LimitedPassthrough } = require('../lib/limited-passthrough');
+const { PassThrough, Transform } = require('stream');
+
+// Helper to collect stream output
+const collectStream = stream =>
+    new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', chunk => chunks.push(chunk));
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+        stream.on('error', reject);
+    });
+
+// ============================================
+// Constructor tests
+// ============================================
+
+module.exports['LimitedPassthrough: constructor with options'] = test => {
+    let stream = new LimitedPassthrough({ maxBytes: 100 });
+    test.equal(stream.maxBytes, 100);
+    test.equal(stream.processed, 0);
+    test.equal(stream.limited, false);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: constructor with no options'] = test => {
+    let stream = new LimitedPassthrough();
+    test.equal(stream.maxBytes, Infinity);
+    test.equal(stream.processed, 0);
+    test.equal(stream.limited, false);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: constructor with null options'] = test => {
+    let stream = new LimitedPassthrough(null);
+    test.equal(stream.maxBytes, Infinity);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: is a Transform stream'] = test => {
+    let stream = new LimitedPassthrough();
+    test.ok(stream instanceof Transform);
+    test.ok(typeof stream.pipe === 'function');
+    test.ok(typeof stream.write === 'function');
+    test.done();
+};
+
+// ============================================
+// _transform tests - no limit
+// ============================================
+
+module.exports['LimitedPassthrough: passes all data when no limit'] = async test => {
+    let stream = new LimitedPassthrough();
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('hello '));
+    stream.write(Buffer.from('world'));
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello world');
+    test.equal(stream.processed, 11);
+    test.equal(stream.limited, false);
+    test.done();
+};
+
+// ============================================
+// _transform tests - with limit
+// ============================================
+
+module.exports['LimitedPassthrough: limits output to maxBytes'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 5 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('hello world'));
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello');
+    test.equal(stream.processed, 5);
+    test.equal(stream.limited, true);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: limits across multiple chunks'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 8 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('hello ')); // 6 bytes
+    stream.write(Buffer.from('world')); // 5 bytes, only 2 should pass
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello wo');
+    test.equal(stream.processed, 8);
+    test.equal(stream.limited, true);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: drops data after limit reached'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 5 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('hello')); // exactly 5 bytes
+    stream.write(Buffer.from(' world')); // should be dropped
+    stream.write(Buffer.from('!')); // should be dropped
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello');
+    test.equal(stream.limited, true);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: handles exact boundary'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 5 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('hello')); // exactly 5 bytes
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello');
+    test.equal(stream.processed, 5);
+    test.equal(stream.limited, true);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: zero maxBytes treated as Infinity'] = async test => {
+    // Note: maxBytes: 0 is falsy, so constructor uses Infinity instead
+    let stream = new LimitedPassthrough({ maxBytes: 0 });
+    test.equal(stream.maxBytes, Infinity);
+
+    let output = collectStream(stream);
+    stream.write(Buffer.from('hello'));
+    stream.end();
+
+    let result = await output;
+    // All data passes through since 0 is treated as Infinity
+    test.equal(result.toString(), 'hello');
+    test.done();
+};
+
+module.exports['LimitedPassthrough: handles limit of 1 byte'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 1 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('hello'));
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'h');
+    test.equal(stream.processed, 1);
+    test.equal(stream.limited, true);
+    test.done();
+};
+
+// ============================================
+// Edge cases
+// ============================================
+
+module.exports['LimitedPassthrough: handles empty writes'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 10 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from(''));
+    stream.write(Buffer.from('hello'));
+    stream.write(Buffer.from(''));
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello');
+    test.equal(stream.processed, 5);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: handles no writes'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 10 });
+    let output = collectStream(stream);
+
+    stream.end();
+
+    let result = await output;
+    test.equal(result.length, 0);
+    test.equal(stream.processed, 0);
+    test.equal(stream.limited, false);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: tracks processed bytes correctly'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 100 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('12345')); // 5 bytes
+    test.equal(stream.processed, 5);
+
+    stream.write(Buffer.from('67890')); // 5 more bytes
+    test.equal(stream.processed, 10);
+
+    stream.end();
+
+    await output;
+    test.equal(stream.processed, 10);
+    test.done();
+};
+
+// ============================================
+// Integration tests
+// ============================================
+
+module.exports['LimitedPassthrough: works with pipe'] = async test => {
+    let source = new PassThrough();
+    let limiter = new LimitedPassthrough({ maxBytes: 10 });
+    let output = collectStream(source.pipe(limiter));
+
+    source.write('hello ');
+    source.write('wonderful ');
+    source.write('world');
+    source.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'hello wond');
+    test.equal(limiter.limited, true);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: handles large data'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 1000 });
+    let output = collectStream(stream);
+
+    // Write 100 bytes at a time
+    for (let i = 0; i < 20; i++) {
+        stream.write(Buffer.alloc(100, 'x'));
+    }
+    stream.end();
+
+    let result = await output;
+    test.equal(result.length, 1000);
+    test.equal(stream.limited, true);
+    test.done();
+};
+
+module.exports['LimitedPassthrough: single byte writes'] = async test => {
+    let stream = new LimitedPassthrough({ maxBytes: 3 });
+    let output = collectStream(stream);
+
+    stream.write(Buffer.from('a'));
+    stream.write(Buffer.from('b'));
+    stream.write(Buffer.from('c'));
+    stream.write(Buffer.from('d')); // should be dropped
+    stream.write(Buffer.from('e')); // should be dropped
+    stream.end();
+
+    let result = await output;
+    test.equal(result.toString(), 'abc');
+    test.done();
+};

package/test/memory-cleanup-test.js

@@ -0,0 +1,144 @@
+'use strict';
+
+/**
+ * Tests for memory cleanup on connection close
+ */
+
+const { ImapFlow } = require('../lib/imap-flow');
+
+exports['Memory Cleanup Tests'] = {
+    'should clean up streamer on close without connection'(test) {
+        const client = new ImapFlow({
+            host: '127.0.0.1',
+            port: 1,
+            secure: false,
+            logger: false
+        });
+
+        // Check initial state
+        test.ok(client.streamer, 'streamer should exist');
+        test.ok(!client.streamer.destroyed, 'streamer should not be destroyed initially');
+
+        // Close without connecting
+        client.close();
+
+        // Verify cleanup
+        test.ok(client.streamer.destroyed, 'streamer should be destroyed after close');
+        test.equal(client.streamer.listenerCount('error'), 0, 'error listeners should be removed');
+        test.equal(client.folders.size, 0, 'folders should be cleared');
+        test.equal(client.requestTagMap.size, 0, 'requestTagMap should be cleared');
+        test.ok(client.isClosed, 'client should be marked as closed');
+
+        test.done();
+    },
+
+    'should remove event listeners on close'(test) {
+        const client = new ImapFlow({
+            host: '127.0.0.1',
+            port: 1,
+            secure: false,
+            logger: false
+        });
+
+        // Add a readable listener as if connect was called
+        client.socketReadable = () => {};
+        client.streamer.on('readable', client.socketReadable);
+
+        // Verify listener was added
+        test.equal(client.streamer.listenerCount('readable'), 1, 'readable listener should be present');
+
+        client.close();
+
+        // Check listeners after close
+        test.equal(client.streamer.listenerCount('readable'), 0, 'readable listener should be removed');
+        test.equal(client.streamer.listenerCount('error'), 0, 'error listeners should be removed');
+
+        test.done();
+    },
+
+    'should clear internal structures on close'(test) {
+        const client = new ImapFlow({
+            host: '127.0.0.1',
+            port: 1,
+            secure: false,
+            logger: false
+        });
+
+        // Add some data to internal structures
+        client.folders.set('INBOX', { path: 'INBOX' });
+        client.folders.set('Sent', { path: 'Sent' });
+        client.requestTagMap.set('A001', { tag: 'A001' });
+        client.requestTagMap.set('A002', { tag: 'A002' });
+
+        test.equal(client.folders.size, 2, 'folders should have entries');
+        test.equal(client.requestTagMap.size, 2, 'requestTagMap should have entries');
+
+        client.close();
+
+        test.equal(client.folders.size, 0, 'folders should be cleared after close');
+        test.equal(client.requestTagMap.size, 0, 'requestTagMap should be cleared after close');
+
+        test.done();
+    },
+
+    'should handle multiple close calls gracefully'(test) {
+        const client = new ImapFlow({
+            host: '127.0.0.1',
+            port: 1,
+            secure: false,
+            logger: false
+        });
+
+        // Call close multiple times
+        test.doesNotThrow(() => {
+            client.close();
+            client.close();
+            client.close();
+        }, 'multiple close calls should not throw');
+
+        test.ok(client.isClosed, 'client should be marked as closed');
+
+        test.done();
+    },
+
+    'should properly set state on close'(test) {
+        const client = new ImapFlow({
+            host: '127.0.0.1',
+            port: 1,
+            secure: false,
+            logger: false
+        });
+
+        test.equal(client.state, client.states.NOT_AUTHENTICATED, 'initial state should be NOT_AUTHENTICATED');
+        test.equal(client.usable, false, 'usable should be false initially');
+        test.equal(client.isClosed, false, 'isClosed should be false initially');
+
+        client.close();
+
+        test.equal(client.state, client.states.LOGOUT, 'state should be LOGOUT after close');
+        test.equal(client.usable, false, 'usable should be false after close');
+        test.equal(client.isClosed, true, 'isClosed should be true after close');
+
+        test.done();
+    },
+
+    'should emit close event'(test) {
+        const client = new ImapFlow({
+            host: '127.0.0.1',
+            port: 1,
+            secure: false,
+            logger: false
+        });
+
+        let closeEmitted = false;
+        client.on('close', () => {
+            closeEmitted = true;
+        });
+
+        client.close();
+
+        test.ok(closeEmitted, 'close event should be emitted');
+
+        test.done();
+    }
+};