imapflow 1.2.13 → 1.2.14

package/test/imapflow-test.js

@@ -42,3 +42,215 @@ module.exports['Create imapflow instance with custom logger'] = async test => {
     }
     test.done();
 };
+
+// ---------------------------------------------------------------------------
+// Helpers for testing prototype methods on a mock context
+// ---------------------------------------------------------------------------
+const createFetchContext = runOverride => ({
+    mailbox: { path: 'INBOX', exists: 10 },
+    isClosed: false,
+    socket: { destroyed: false },
+    resolveRange: async range => range,
+    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/search-compiler-test.js

@@ -861,3 +861,77 @@ module.exports['Search Compiler: OR combined with other criteria'] = test => {
     test.ok(hasAttr(compiled, 'OR'));
     test.done();
 };
+
+// ============================================
+// OR tree structure tests
+// ============================================
+
+module.exports['Search Compiler: OR with 3 conditions builds binary tree'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, {
+        or: [{ from: 'alice' }, { to: 'bob' }, { subject: 'test' }]
+    });
+
+    test.ok(hasAttr(compiled, 'OR'), 'should contain OR atom');
+    test.ok(hasAttr(compiled, 'alice'), 'should contain alice');
+    test.ok(hasAttr(compiled, 'bob'), 'should contain bob');
+    test.ok(hasAttr(compiled, 'test'), 'should contain test');
+    test.ok(hasAttr(compiled, 'FROM'), 'should contain FROM');
+    test.ok(hasAttr(compiled, 'TO'), 'should contain TO');
+    test.ok(hasAttr(compiled, 'SUBJECT'), 'should contain SUBJECT');
+    test.done();
+};
+
+module.exports['Search Compiler: OR with 5 conditions produces 4 OR atoms'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, {
+        or: [{ from: 'a' }, { from: 'b' }, { from: 'c' }, { from: 'd' }, { from: 'e' }]
+    });
+
+    // 5 conditions need 4 OR atoms in a binary tree structure
+    let orCount = compiled.filter(a => a.value === 'OR').length;
+    test.equal(orCount, 4, 'should have exactly 4 OR atoms for 5 conditions');
+    test.ok(hasAttr(compiled, 'a'), 'should contain a');
+    test.ok(hasAttr(compiled, 'b'), 'should contain b');
+    test.ok(hasAttr(compiled, 'c'), 'should contain c');
+    test.ok(hasAttr(compiled, 'd'), 'should contain d');
+    test.ok(hasAttr(compiled, 'e'), 'should contain e');
+    test.done();
+};
+
+// ============================================
+// Unicode CHARSET in HEADER searches
+// ============================================
+
+module.exports['Search Compiler: Unicode header search without UTF8=ACCEPT adds CHARSET'] = test => {
+    let connection = createMockConnection({
+        enabled: new Set()
+    });
+    let compiled = searchCompiler(connection, {
+        header: { subject: 'caf\u00e9' }
+    });
+
+    test.ok(hasAttr(compiled, 'CHARSET'), 'should have CHARSET prefix');
+    test.ok(hasAttr(compiled, 'UTF-8'), 'should have UTF-8 value');
+    // CHARSET and UTF-8 should be the first two entries
+    test.equal(compiled[0].value, 'CHARSET', 'CHARSET should be first');
+    test.equal(compiled[1].value, 'UTF-8', 'UTF-8 should be second');
+    test.ok(hasAttr(compiled, 'HEADER'), 'should contain HEADER');
+    test.ok(hasAttr(compiled, 'caf\u00e9'), 'should contain the unicode value');
+    test.done();
+};
+
+module.exports['Search Compiler: Unicode header search with UTF8=ACCEPT skips CHARSET'] = test => {
+    let connection = createMockConnection({
+        enabled: new Set(['UTF8=ACCEPT'])
+    });
+    let compiled = searchCompiler(connection, {
+        header: { subject: 'caf\u00e9' }
+    });
+
+    test.ok(!hasAttr(compiled, 'CHARSET'), 'should NOT have CHARSET prefix');
+    test.ok(!hasAttr(compiled, 'UTF-8'), 'should NOT have UTF-8 value');
+    test.ok(hasAttr(compiled, 'HEADER'), 'should contain HEADER');
+    test.ok(hasAttr(compiled, 'caf\u00e9'), 'should contain the unicode value');
+    test.done();
+};

package/test/token-parser-test.js

@@ -0,0 +1,374 @@
+/*eslint no-unused-expressions: 0, prefer-arrow-callback: 0 */
+
+'use strict';
+
+const { parser } = require('../lib/handler/imap-handler');
+
+let asyncWrapper = (test, handler) => {
+    handler(test)
+        .then(() => test.done())
+        .catch(err => {
+            test.ifError(err);
+            test.done();
+        });
+};
+
+// Error path tests
+//
+// NOTE: All error inputs use a non-status command (FETCH) rather than OK/NO/BAD/BYE.
+// Status commands consume their entire remainder as human-readable text and never
+// invoke the TokenParser, so errors like E9/E10/E13 cannot be triggered through
+// the public parser() API when the command is a status response.
+//
+// Error-path tests use asyncWrapper with an internal try/catch so that err.code
+// can be asserted. The handler re-throws when no error was caught so that a missing
+// rejection is still surfaced as a test failure.
+
+/**
+ * E9: Unclosed quoted string. The node's isClosed flag remains false when
+ * getAttributes() walks the tree, triggering ParserError9.
+ */
+module.exports['Token Parser: E9: unclosed quoted string throws ParserError9'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH "unterminated');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError9');
+    });
+
+/**
+ * E10: Unexpected list terminator. A ')' is encountered when the current node
+ * is not a LIST node, triggering ParserError10.
+ */
+module.exports['Token Parser: E10: unexpected ) throws ParserError10'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH )');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError10');
+    });
+
+/**
+ * E13: Unexpected control character. A character below 0x80 that is not in
+ * ATOM-CHAR and not one of the explicitly allowed exceptions (\, %) triggers
+ * ParserError13 in the STATE_NORMAL default branch.
+ * \x01 is a control character excluded from ATOM-CHAR.
+ */
+module.exports['Token Parser: E13: control character in attribute position throws ParserError13'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH \x01rest');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError13');
+    });
+
+/**
+ * E18: Backslash escape at end of quoted string input. When a backslash is
+ * encountered in STATE_STRING and there is no following character (i >= len),
+ * ParserError18 is thrown.
+ * The JS string '* FETCH "test\\' represents the IMAP input: * FETCH "test\
+ */
+module.exports['Token Parser: E18: escape at end of quoted string throws ParserError18'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH "test\\');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError18');
+    });
+
+/**
+ * E23: Empty literal braces. When '}' is encountered in STATE_LITERAL before
+ * any digit has been stored in literalLength, ParserError23 is thrown because
+ * the check is: if (!('literalLength' in this.currentNode)) throw E23.
+ */
+module.exports['Token Parser: E23: empty literal braces throws ParserError23'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH {}', { literals: [] });
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError23');
+    });
+
+/**
+ * E25: Non-digit character inside literal size braces. Any character inside
+ * {…} that is not a digit (and not '}' or '+' with literalPlus) triggers
+ * ParserError25.
+ */
+module.exports['Token Parser: E25: non-digit in literal size throws ParserError25'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH {abc}', { literals: [] });
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError25');
+    });
+
+/**
+ * E26: Leading zero in literal size. After '0' is stored as literalLength,
+ * any following digit triggers ParserError26 because a leading zero is invalid.
+ */
+module.exports['Token Parser: E26: leading zero in literal size throws ParserError26'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH {01}', { literals: [Buffer.from('x')] });
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError26');
+    });
+
+/**
+ * MAX_IMAP_NESTING_REACHED: Nesting depth exceeds MAX_NODE_DEPTH (25).
+ * createNode() throws when node.depth > 25. The root TREE node starts at
+ * depth 0, so depth 1 is the first LIST ('('), and 26 open parens reaches
+ * depth 26 which exceeds the limit.
+ */
+module.exports['Token Parser: MAX_IMAP_NESTING_REACHED: deep nesting throws MAX_IMAP_NESTING_REACHED'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            const depth = 26;
+            const input = '* FETCH ' + '('.repeat(depth) + 'x' + ')'.repeat(depth);
+            await parser(input);
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'MAX_IMAP_NESTING_REACHED');
+    });
+
+// Happy-path tests
+
+/**
+ * NIL atom is returned as null in the attributes array. The ATOM node whose
+ * value is "NIL" (case-insensitive) is converted to null in getAttributes().
+ */
+module.exports['Token Parser: NIL atom is parsed as null'] = test =>
+    asyncWrapper(test, async test => {
+        const result = await parser('* FETCH NIL');
+        const attrs = result.attributes;
+        test.ok(Array.isArray(attrs), 'attributes should be an array');
+        test.equal(attrs.length, 1, 'should have exactly one attribute');
+        test.strictEqual(attrs[0], null, 'NIL should be parsed as null');
+    });
+
+/**
+ * Nested lists produce nested arrays in the attributes output.
+ * Input ((a b)) produces: [ [ [ {a}, {b} ] ] ] — the attributes array contains
+ * one outer list which contains one inner list with two atom elements.
+ */
+module.exports['Token Parser: nested lists produce nested arrays'] = test =>
+    asyncWrapper(test, async test => {
+        const result = await parser('* FETCH ((a b))');
+        const attrs = result.attributes;
+        test.ok(Array.isArray(attrs), 'attributes should be an array');
+        const outer = attrs[0];
+        test.ok(Array.isArray(outer), 'outer list should be an array');
+        const inner = outer[0];
+        test.ok(Array.isArray(inner), 'inner list should be an array');
+        test.equal(inner.length, 2, 'inner list should have 2 elements');
+        test.equal(inner[0].value, 'a', 'first inner element value should be a');
+        test.equal(inner[1].value, 'b', 'second inner element value should be b');
+    });
+
+/**
+ * Quoted string with escaped double-quote characters. The backslash-escape
+ * mechanism converts \" to " in the parsed value. The JS literal
+ * '* FETCH "hello \\"world\\""' represents: * FETCH "hello \"world\""
+ */
+module.exports['Token Parser: quoted string with escaped quotes is parsed correctly'] = test =>
+    asyncWrapper(test, async test => {
+        const result = await parser('* FETCH "hello \\"world\\""');
+        const attrs = result.attributes;
+        test.ok(Array.isArray(attrs), 'attributes should be an array');
+        test.equal(attrs.length, 1, 'should have exactly one attribute');
+        test.equal(attrs[0].type, 'STRING', 'type should be STRING');
+        test.equal(attrs[0].value, 'hello "world"', 'escaped quotes should be unescaped');
+    });
+
+/**
+ * Empty quoted string results in a STRING attribute with an empty value.
+ */
+module.exports['Token Parser: empty quoted string produces STRING with empty value'] = test =>
+    asyncWrapper(test, async test => {
+        const result = await parser('* FETCH ""');
+        const attrs = result.attributes;
+        test.ok(Array.isArray(attrs), 'attributes should be an array');
+        test.equal(attrs.length, 1, 'should have exactly one attribute');
+        test.equal(attrs[0].type, 'STRING', 'type should be STRING');
+        test.equal(attrs[0].value, '', 'value should be empty string');
+    });
+
+/**
+ * Literal data provided via the literals option is parsed into a LITERAL attribute.
+ * When options.literals is set and '}' is encountered with a valid size, the next
+ * Buffer in the literals array is used as the literal value directly.
+ * The literal size in braces must be followed by \r\n or \n per IMAP protocol.
+ */
+module.exports['Token Parser: literal with pre-parsed data produces LITERAL attribute'] = test =>
+    asyncWrapper(test, async test => {
+        const data = Buffer.from('hello');
+        const result = await parser('* FETCH {5}\r\n', { literals: [data] });
+        const attrs = result.attributes;
+        test.ok(Array.isArray(attrs), 'attributes should be an array');
+        test.equal(attrs.length, 1, 'should have exactly one attribute');
+        test.equal(attrs[0].type, 'LITERAL', 'type should be LITERAL');
+        test.ok(Buffer.isBuffer(attrs[0].value), 'literal value should be a Buffer');
+        test.equal(attrs[0].value.toString(), 'hello', 'literal value should match provided buffer');
+    });
+
+/**
+ * A plain ATOM token produces an ATOM attribute with the correct string value.
+ */
+module.exports['Token Parser: atom value produces ATOM attribute'] = test =>
+    asyncWrapper(test, async test => {
+        const result = await parser('* FETCH INBOX');
+        const attrs = result.attributes;
+        test.ok(Array.isArray(attrs), 'attributes should be an array');
+        test.equal(attrs.length, 1, 'should have exactly one attribute');
+        test.equal(attrs[0].type, 'ATOM', 'type should be ATOM');
+        test.equal(attrs[0].value, 'INBOX', 'value should be INBOX');
+    });
+
+/**
+ * E29: Range separator ':' after a character that is not a digit or '*'.
+ * Input "1,:5" starts as ATOM "1", ',' triggers SEQUENCE reclassification and
+ * appends ',' (value becomes "1,"). Then ':' fires E29 because last char ','
+ * is not a digit or '*'.
+ */
+module.exports['Token Parser: E29: range separator after non-digit/non-star throws ParserError29'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH 1,:5');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError29');
+    });
+
+/**
+ * E30: Wildcard '*' when last char is not ',' or ':'.
+ * Input "1:2*" enters SEQUENCE after "1:" and appends "2" (value "1:2").
+ * Then '*' fires E30 because last char '2' is not ',' or ':'.
+ */
+module.exports['Token Parser: E30: wildcard after digit throws ParserError30'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH 1:2*');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError30');
+    });
+
+/**
+ * E31: Separator ',' after a character that is not a digit or '*'.
+ * Input "1:,5" enters SEQUENCE after "1" and appends ':' (value "1:").
+ * Then ',' fires E31 because last char ':' is not a digit or '*'.
+ */
+module.exports['Token Parser: E31: comma after colon throws ParserError31'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH 1:,5');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError31');
+    });
+
+/**
+ * E32: Separator ',' after bare '*' (not in a range).
+ * Input "*,5" starts SEQUENCE with value "*". Then ',' passes E31
+ * (last char '*' satisfies the check) but fires E32 because last char
+ * is '*' and the char before it (at(-2)) is not ':'.
+ */
+module.exports['Token Parser: E32: comma after bare star throws ParserError32'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH *,5');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError32');
+    });
+
+/**
+ * E33: Non-digit, non-special character in sequence position.
+ * Input "1:a" enters SEQUENCE after "1" and appends ':' (value "1:").
+ * Then 'a' is not a digit, not ':', not '*', not ',' so E33 fires.
+ */
+module.exports['Token Parser: E33: non-digit non-special char in sequence throws ParserError33'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH 1:a');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError33');
+    });
+
+/**
+ * E34: Digit immediately after '*'.
+ * Input "*1" starts SEQUENCE with value "*". Then '1' is a digit but
+ * last char is '*', so E34 fires (digits cannot follow '*').
+ */
+module.exports['Token Parser: E34: digit after star throws ParserError34'] = test =>
+    asyncWrapper(test, async test => {
+        let err;
+        try {
+            await parser('* FETCH *1');
+        } catch (e) {
+            err = e;
+        }
+        if (!err) throw new Error('Expected parser to throw but it did not');
+        test.ok(err, 'expected an error to be thrown');
+        test.equal(err.code, 'ParserError34');
+    });