|
| 1 | +'use strict'; |
| 2 | +const common = require('../common'); |
| 3 | +const { start } = require('node:repl'); |
| 4 | +const assert = require('node:assert'); |
| 5 | +const { PassThrough } = require('node:stream'); |
| 6 | +const { once } = require('node:events'); |
| 7 | +const test = require('node:test'); |
| 8 | +const { spawn } = require('node:child_process'); |
| 9 | + |
| 10 | +function* generateCases() { |
| 11 | + for (const async of [false, true]) { |
| 12 | + for (const handleErrorReturn of ['ignore', 'print', 'unhandled', 'badvalue']) { |
| 13 | + if (handleErrorReturn === 'badvalue' && async) { |
| 14 | + // Handled through a separate test using a child process |
| 15 | + continue; |
| 16 | + } |
| 17 | + yield { async, handleErrorReturn }; |
| 18 | + } |
| 19 | + } |
| 20 | +} |
| 21 | + |
| 22 | +for (const { async, handleErrorReturn } of generateCases()) { |
| 23 | + test(`async: ${async}, handleErrorReturn: ${handleErrorReturn}`, async () => { |
| 24 | + let err; |
| 25 | + const options = { |
| 26 | + input: new PassThrough(), |
| 27 | + output: new PassThrough().setEncoding('utf8'), |
| 28 | + handleError: common.mustCall((e) => { |
| 29 | + err = e; |
| 30 | + queueMicrotask(() => repl.emit('handled-error')); |
| 31 | + return handleErrorReturn; |
| 32 | + }) |
| 33 | + }; |
| 34 | + |
| 35 | + let uncaughtExceptionEvent; |
| 36 | + if (handleErrorReturn === 'unhandled' && async) { |
| 37 | + process.removeAllListeners('uncaughtException'); // Remove the test runner's handler |
| 38 | + uncaughtExceptionEvent = once(process, 'uncaughtException'); |
| 39 | + } |
| 40 | + |
| 41 | + const repl = start(options); |
| 42 | + const inputString = async ? |
| 43 | + 'setImmediate(() => { throw new Error("testerror") })\n42\n' : |
| 44 | + 'throw new Error("testerror")\n42\n'; |
| 45 | + if (handleErrorReturn === 'badvalue') { |
| 46 | + assert.throws(() => options.input.end(inputString), /ERR_INVALID_STATE/); |
| 47 | + return; |
| 48 | + } |
| 49 | + options.input.end(inputString); |
| 50 | + |
| 51 | + await once(repl, 'handled-error'); |
| 52 | + assert.strictEqual(err.message, 'testerror'); |
| 53 | + const outputString = options.output.read(); |
| 54 | + assert.match(outputString, /42/); |
| 55 | + |
| 56 | + if (handleErrorReturn === 'print') { |
| 57 | + assert.match(outputString, /testerror/); |
| 58 | + } else { |
| 59 | + assert.doesNotMatch(outputString, /testerror/); |
| 60 | + } |
| 61 | + |
| 62 | + if (uncaughtExceptionEvent) { |
| 63 | + const [uncaughtErr] = await uncaughtExceptionEvent; |
| 64 | + assert.strictEqual(uncaughtErr, err); |
| 65 | + } |
| 66 | + }); |
| 67 | +} |
| 68 | + |
| 69 | +test('async: true, handleErrorReturn: badvalue', async () => { |
| 70 | + // Can't test this the same way as the other combinations |
| 71 | + // since this will take the process down in a way that |
| 72 | + // cannot be caught. |
| 73 | + const proc = spawn(process.execPath, ['-e', ` |
| 74 | + require('node:repl').start({ |
| 75 | + handleError: () => 'badvalue' |
| 76 | + }) |
| 77 | + `], { encoding: 'utf8', stdio: 'pipe' }); |
| 78 | + proc.stdin.end('throw new Error("foo");'); |
| 79 | + let stderr = ''; |
| 80 | + proc.stderr.setEncoding('utf8').on('data', (data) => stderr += data); |
| 81 | + const [exit] = await once(proc, 'close'); |
| 82 | + assert.strictEqual(exit, 1); |
| 83 | + assert.match(stderr, /ERR_INVALID_STATE.+badvalue/); |
| 84 | +}); |