test-repl.js

// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';
const common = require('../common');

common.skipIfInspectorDisabled();

const fixtures = require('../common/fixtures');
const tmpdir = require('../common/tmpdir');
const assert = require('assert');
const net = require('net');
const repl = require('repl');
const { inspect } = require('util');

const message = 'Read, Eval, Print Loop';
const prompt_unix = 'node via Unix socket> ';
const prompt_tcp = 'node via TCP socket> ';

// Absolute path to test/fixtures/a.js
const moduleFilename = fixtures.path('a');

// Function for REPL to run
globalThis.invoke_me = function(arg) {
  return `invoked ${arg}`;
};

async function runReplTests(socket, prompt, tests) {
  let lineBuffer = '';

  for (const { send, expect } of tests) {
    // Expect can be a single line or multiple lines
    const expectedLines = Array.isArray(expect) ? expect : [ expect ];

    console.error('\n------------');
    console.error('out:', JSON.stringify(send));
    socket.write(`${send}\n`);

    for (const expectedLine of expectedLines) {
      while (!lineBuffer.includes('\n')) {
        lineBuffer += await event(socket, expect);

        // Cut away the initial prompt
        while (lineBuffer.startsWith(prompt))
          lineBuffer = lineBuffer.slice(prompt.length);

        // Allow to match partial text if no newline was received, because
        // sending newlines from the REPL itself would be redundant
        // (e.g. in the `| ` multiline prompt: The user already pressed
        // enter for that, so the REPL shouldn't do it again!).
        if (lineBuffer === expectedLine && !expectedLine.includes('\n'))
          lineBuffer += '\n';
      }

      // Split off the current line.
      const newlineOffset = lineBuffer.indexOf('\n');
      let actualLine = lineBuffer.slice(0, newlineOffset);
      lineBuffer = lineBuffer.slice(newlineOffset + 1);

      // This might have been skipped in the loop above because the buffer
      // already contained a \n to begin with and the entire loop was skipped.
      while (actualLine.startsWith(prompt))
        actualLine = actualLine.slice(prompt.length);

      console.error('in:', JSON.stringify(actualLine));

      // Match a string directly, or a RegExp.
      if (typeof expectedLine === 'string') {
        assert.strictEqual(actualLine, expectedLine);
      } else {
        assert.match(actualLine, expectedLine);
      }
    }
  }

  const remainder = socket.read();
  assert(remainder === '' || remainder === null);
}

const unixTests = [
  {
    send: '',
    expect: ''
  },
  {
    send: 'message',
    expect: `'${message}'`
  },
  {
    send: 'invoke_me(987)',
    expect: '\'invoked 987\''
  },
  {
    send: 'a = 12345',
    expect: '12345'
  },
  {
    send: '{a:1}',
    expect: '{ a: 1 }'
  },
];

const strictModeTests = [
  {
    send: 'ref = 1',
    expect: [/^Uncaught ReferenceError:\s/, /^ {4}at /]
  },
];

const possibleTokensAfterIdentifierWithLineBreak = [
  '(\n)',
  '[\n0]',
  '+\n1', '- \n1', '* \n1', '/ \n1', '% \n1', '** \n1',
  '== \n1', '=== \n1', '!= \n1', '!== \n1', '< \n1', '> \n1', '<= \n1', '>= \n1',
  '&& \n1', '|| \n1', '?? \n1',
  '= \n1', '+= \n1', '-= \n1', '*= \n1', '/= \n1', '%= \n1',
  ': \n',
  '? \n1: 1',
];

const errorTests = [
  // Uncaught error throws and prints out
  {
    send: 'throw new Error(\'test error\');',
    expect: ['Uncaught Error: test error', /^ {4}at /]
  },
  {
    send: "throw { foo: 'bar' };",
    expect: "Uncaught { foo: 'bar' }"
  },
  // Common syntax error is treated as multiline command
  {
    send: 'function test_func() {',
    expect: '| '
  },
  // You can recover with the .break command
  {
    send: '.break',
    expect: ''
  },
  // But passing the same string to eval() should throw
  {
    send: 'eval("function test_func() {")',
    expect: [/^Uncaught SyntaxError: /]
  },
  // Can handle multiline template literals
  {
    send: '`io.js',
    expect: '| '
  },
  // Special REPL commands still available
  {
    send: '.break',
    expect: ''
  },
  // Template expressions
  {
    send: '`io.js ${"1.0"',
    expect: '| '
  },
  {
    send: '+ ".2"}`',
    expect: '\'io.js 1.0.2\''
  },
  {
    send: '`io.js ${',
    expect: '| '
  },
  {
    send: '"1.0" + ".2"}`',
    expect: '\'io.js 1.0.2\''
  },
  // Dot prefix in multiline commands aren't treated as commands
  {
    send: '("a"',
    expect: '| '
  },
  {
    send: '.charAt(0))',
    expect: '\'a\''
  },
  // Floating point numbers are not interpreted as REPL commands.
  {
    send: '.1234',
    expect: '0.1234'
  },
  // Floating point expressions are not interpreted as REPL commands
  {
    send: '.1+.1',
    expect: '0.2'
  },
  // Can parse valid JSON
  {
    send: 'JSON.parse(\'{"valid": "json"}\');',
    expect: '{ valid: \'json\' }'
  },
  // Invalid input to JSON.parse error is special case of syntax error,
  // should throw
  {
    send: 'JSON.parse(\'{invalid: \\\'json\\\'}\');',
    expect: [
      'Uncaught:',
      /^SyntaxError: /,
    ],
  },
  // End of input to JSON.parse error is special case of syntax error,
  // should throw
  {
    send: 'JSON.parse(\'066\');',
    expect: [/^Uncaught SyntaxError: /]
  },
  // should throw
  {
    send: 'JSON.parse(\'{\');',
    expect: [
      'Uncaught:',
      /^SyntaxError: /,
    ],
  },
  // invalid RegExps are a special case of syntax error,
  // should throw
  {
    send: '/(/;',
    expect: [/^Uncaught SyntaxError: /]
  },
  // invalid RegExp modifiers are a special case of syntax error,
  // should throw (GH-4012)
  {
    send: 'new RegExp("foo", "wrong modifier");',
    expect: [/^Uncaught SyntaxError: /]
  },
  // Strict mode syntax errors should be caught (GH-5178)
  {
    send: '(function() { "use strict"; return 0755; })()',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '(function(a, a, b) { "use strict"; return a + b + c; })()',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '(function() { "use strict"; with (this) {} })()',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '(function() { "use strict"; var x; delete x; })()',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '(function() { "use strict"; eval = 17; })()',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '(function() { "use strict"; if (true) function f() { } })()',
    expect: ['Uncaught:', /^SyntaxError: /]
  },
  // Named functions can be used:
  {
    send: 'function blah() { return 1; }',
    expect: 'undefined'
  },
  {
    send: 'blah()',
    expect: '1'
  },
  // Functions should not evaluate twice (#2773)
  {
    send: 'var I = [1,2,3,function() {}]; I.pop()',
    expect: '[Function (anonymous)]'
  },
  // Multiline object
  {
    send: '{}),({}',
    expect: '| ',
  },
  {
    send: '}',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '{ a: ',
    expect: '| '
  },
  {
    send: '1 }',
    expect: '{ a: 1 }'
  },
  // Multiline string-keyed object (e.g. JSON)
  {
    send: '{ "a": ',
    expect: '| '
  },
  {
    send: '1 }',
    expect: '{ a: 1 }'
  },
  // Multiline class with private member.
  {
    send: 'class Foo { #private = true ',
    expect: '| '
  },
  // Class field with bigint.
  {
    send: 'num = 123456789n',
    expect: '| '
  },
  // Static class features.
  {
    send: 'static foo = "bar" }',
    expect: 'undefined'
  },
  // Multiline anonymous function with comment
  {
    send: '(function() {',
    expect: '| '
  },
  {
    send: '// blah',
    expect: '| '
  },
  {
    send: 'return 1n;',
    expect: '| '
  },
  {
    send: '})()',
    expect: '1n'
  },
  // Multiline function call
  {
    send: 'function f(){}; f(f(1,',
    expect: '| '
  },
  {
    send: '2)',
    expect: '| '
  },
  {
    send: ')',
    expect: 'undefined'
  },
  // `npm` prompt error message.
  {
    send: 'npm install foobar',
    expect: [
      'npm should be run outside of the Node.js REPL, in your normal shell.',
      '(Press Ctrl+D to exit.)',
    ]
  },
  {
    send: 'let npm = () => {};',
    expect: 'undefined'
  },
  ...possibleTokensAfterIdentifierWithLineBreak.map((token) => (
    {
      send: `npm ${token}; undefined`,
      expect: '| undefined'
    }
  )),
  {
    send: '(function() {\n\nreturn 1;\n})()',
    expect: '| | | 1'
  },
  {
    send: '{\n\na: 1\n}',
    expect: '| | | { a: 1 }'
  },
  {
    send: 'url.format("http://google.com")',
    expect: '\'http://google.com/\''
  },
  {
    send: 'var path = 42; path',
    expect: '42'
  },
  // This makes sure that we don't print `undefined` when we actually print
  // the error message
  {
    send: '.invalid_repl_command',
    expect: 'Invalid REPL keyword'
  },
  // This makes sure that we don't crash when we use an inherited property as
  // a REPL command
  {
    send: '.toString',
    expect: 'Invalid REPL keyword'
  },
  // Fail when we are not inside a String and a line continuation is used
  {
    send: '[] \\',
    expect: [/^Uncaught SyntaxError: /]
  },
  // Do not fail when a String is created with line continuation
  {
    send: '\'the\\\nfourth\\\neye\'',
    expect: ['| | \'thefourtheye\'']
  },
  // Don't fail when a partial String is created and line continuation is used
  // with whitespace characters at the end of the string. We are to ignore it.
  // This test is to make sure that we properly remove the whitespace
  // characters at the end of line, unlike the buggy `trimWhitespace` function
  {
    send: '  \t    .break  \t  ',
    expect: ''
  },
  // Multiline strings preserve whitespace characters in them
  {
    send: '\'the \\\n   fourth\t\t\\\n  eye  \'',
    expect: '| | \'the    fourth\\t\\t  eye  \''
  },
  // More than one multiline strings also should preserve whitespace chars
  {
    send: '\'the \\\n   fourth\' +  \'\t\t\\\n  eye  \'',
    expect: '| | \'the    fourth\\t\\t  eye  \''
  },
  // using REPL commands within a string literal should still work
  {
    send: '\'\\\n.break',
    expect: '| ' + prompt_unix
  },
  // Using REPL command "help" within a string literal should still work
  {
    send: '\'thefourth\\\n.help\neye\'',
    expect: [
      /\.break/,
      /\.clear/,
      /\.exit/,
      /\.help/,
      /\.load/,
      /\.save/,
      '',
      'Press Ctrl+C to abort current expression, Ctrl+D to exit the REPL',
      /'thefourtheye'/,
    ]
  },
  // Check for wrapped objects.
  {
    send: '{ a: 1 }.a', // ({ a: 1 }.a);
    expect: '1'
  },
  {
    send: '{ a: 1 }.a;', // { a: 1 }.a;
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: '{ a: 1 }["a"] === 1', // ({ a: 1 }['a'] === 1);
    expect: 'true'
  },
  {
    send: '{ a: 1 }["a"] === 1;', // { a: 1 }; ['a'] === 1;
    expect: 'false'
  },
  // Empty lines in the REPL should be allowed
  {
    send: '\n\r\n\r\n',
    expect: ''
  },
  // Empty lines in the string literals should not affect the string
  {
    send: '\'the\\\n\\\nfourtheye\'\n',
    expect: '| | \'thefourtheye\''
  },
  // Regression tests for https://github.com/nodejs/node/issues/2749
  {
    send: 'function x() {\nreturn \'\\n\';\n }',
    expect: '| | undefined'
  },
  {
    send: 'function x() {\nreturn \'\\\\\';\n }',
    expect: '| | undefined'
  },
  // Regression tests for https://github.com/nodejs/node/issues/3421
  {
    send: 'function x() {\n//\'\n }',
    expect: '| | undefined'
  },
  {
    send: 'function x() {\n//"\n }',
    expect: '| | undefined'
  },
  {
    send: 'function x() {//\'\n }',
    expect: '| undefined'
  },
  {
    send: 'function x() {//"\n }',
    expect: '| undefined'
  },
  {
    send: 'function x() {\nvar i = "\'";\n }',
    expect: '| | undefined'
  },
  {
    send: 'function x(/*optional*/) {}',
    expect: 'undefined'
  },
  {
    send: 'function x(/* // 5 */) {}',
    expect: 'undefined'
  },
  {
    send: '// /* 5 */',
    expect: 'undefined'
  },
  {
    send: '"//"',
    expect: '\'//\''
  },
  {
    send: '"data /*with*/ comment"',
    expect: '\'data /*with*/ comment\''
  },
  {
    send: 'function x(/*fn\'s optional params*/) {}',
    expect: 'undefined'
  },
  {
    send: '/* \'\n"\n\'"\'\n*/',
    expect: '| | | undefined'
  },
  // REPL should get a normal require() function, not one that allows
  // access to internal modules without the --expose-internals flag.
  {
    // Shrink the stack trace to avoid having to update this test whenever the
    // implementation of require() changes. It's set to 5 because somehow setting it
    // to a lower value breaks the error formatting and the message becomes
    // "Uncaught [Error...", which is probably a bug(?).
    send: 'Error.stackTraceLimit = 5; require("internal/repl")',
    expect: [
      /^Uncaught Error: Cannot find module 'internal\/repl'/,
      /^Require stack:/,
      /^- <repl>/,  // This just tests MODULE_NOT_FOUND so let's skip the stack trace
      /^ {4}at .*/, // Some stack frame that we have to capture otherwise error message is buggy.
      /^ {4}at .*/, // Some stack frame that we have to capture otherwise error message is buggy.
      /^ {4}at .*/, // Some stack frame that we have to capture otherwise error message is buggy.
      /^ {4}at .*/, // Some stack frame that we have to capture otherwise error message is buggy.
      /^ {4}at .*/, // Some stack frame that we have to capture otherwise error message is buggy.
      "  code: 'MODULE_NOT_FOUND',",
      "  requireStack: [ '<repl>' ]",
      '}',
    ]
  },
  // REPL should handle quotes within regexp literal in multiline mode
  {
    send: "function x(s) {\nreturn s.replace(/'/,'');\n}",
    expect: '| | undefined'
  },
  {
    send: "function x(s) {\nreturn s.replace(/'/,'');\n}",
    expect: '| | undefined'
  },
  {
    send: 'function x(s) {\nreturn s.replace(/"/,"");\n}',
    expect: '| | undefined'
  },
  {
    send: 'function x(s) {\nreturn s.replace(/.*/,"");\n}',
    expect: '| | undefined'
  },
  // Illegal token is not recoverable outside string literal, RegExp literal,
  // or block comment. https://github.com/nodejs/node/issues/3611
  {
    send: 'a = 3.5e',
    expect: [/^Uncaught SyntaxError: /]
  },
  // Mitigate https://github.com/nodejs/node/issues/548
  {
    send: 'function name(){ return "node"; };name()',
    expect: '\'node\''
  },
  {
    send: 'function name(){ return "nodejs"; };name()',
    expect: '\'nodejs\''
  },
  // Avoid emitting repl:line-number for SyntaxError
  {
    send: 'a = 3.5e',
    expect: [/^Uncaught SyntaxError: /]
  },
  // Avoid emitting stack trace
  {
    send: 'a = 3.5e',
    expect: [/^Uncaught SyntaxError: /]
  },

  // https://github.com/nodejs/node/issues/9850
  {
    send: 'function* foo() {}; foo().next();',
    expect: '{ value: undefined, done: true }'
  },

  {
    send: 'function *foo() {}; foo().next();',
    expect: '{ value: undefined, done: true }'
  },

  {
    send: 'function*foo() {}; foo().next();',
    expect: '{ value: undefined, done: true }'
  },

  {
    send: 'function * foo() {}; foo().next()',
    expect: '{ value: undefined, done: true }'
  },

  // https://github.com/nodejs/node/issues/9300
  {
    send: 'function foo() {\nvar bar = 1 / 1; // "/"\n}',
    expect: '| | undefined'
  },

  {
    send: '(function() {\nreturn /foo/ / /bar/;\n}())',
    expect: '| | NaN'
  },

  {
    send: '(function() {\nif (false) {} /bar"/;\n}())',
    expect: '| | undefined'
  },

  // https://github.com/nodejs/node/issues/16483
  {
    send: 'new Proxy({x:42}, {get(){throw null}});',
    expect: 'Proxy [ { x: 42 }, { get: [Function: get] } ]'
  },
  {
    send: 'repl.writer.options.showProxy = false, new Proxy({x:42}, {});',
    expect: 'Proxy({ x: 42 })'
  },

  // Newline within template string maintains whitespace.
  {
    send: '`foo \n`',
    expect: '| \'foo \\n\''
  },
  // Whitespace is not evaluated.
  {
    send: ' \t  \n',
    expect: 'undefined'
  },
  // Do not parse `...[]` as a REPL keyword
  {
    send: '...[]',
    expect: [/^Uncaught SyntaxError: /]
  },
  // Bring back the repl to prompt
  {
    send: '.break',
    expect: ''
  },
  {
    send: 'console.log("Missing comma in arg list" process.version)',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: 'x = {\nfield\n{',
    expect: [/^\| \| Uncaught SyntaxError: /]
  },
  {
    send: '(2 + 3))',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: 'if (typeof process === "object"); {',
    expect: '| '
  },
  {
    send: 'console.log("process is defined");',
    expect: '| '
  },
  {
    send: '} else {',
    expect: [/^Uncaught SyntaxError: /]
  },
  {
    send: 'console',
    expect: [
      'Object [console] {',
      '  log: [Function: log],',
      '  info: [Function: info],',
      '  debug: [Function: debug],',
      '  warn: [Function: warn],',
      '  error: [Function: error],',
      '  dir: [Function: dir],',
      '  time: [Function: time],',
      '  timeEnd: [Function: timeEnd],',
      '  timeLog: [Function: timeLog],',
      '  trace: [Function: trace],',
      '  assert: [Function: assert],',
      '  clear: [Function: clear],',
      '  count: [Function: count],',
      '  countReset: [Function: countReset],',
      '  group: [Function: group],',
      '  groupEnd: [Function: groupEnd],',
      '  table: [Function: table],',
      / {2}dirxml: \[Function: (dirxml|log)],/,
      / {2}groupCollapsed: \[Function: (groupCollapsed|group)],/,
      / {2}Console: \[Function: Console],?/,
      '  profile: [Function: profile],',
      '  profileEnd: [Function: profileEnd],',
      '  timeStamp: [Function: timeStamp],',
      '  context: [Function: context],',
      '  createTask: [Function: createTask]',
      '}',
    ]
  },
];

const tcpTests = [
  {
    send: '',
    expect: ''
  },
  {
    send: 'invoke_me(333)',
    expect: '\'invoked 333\''
  },
  {
    send: 'a += 1',
    expect: '12346'
  },
  {
    send: `require(${JSON.stringify(moduleFilename)}).number`,
    expect: '42'
  },
];

(async function() {
  {
    const [ socket, replServer ] = await startUnixRepl();

    await runReplTests(socket, prompt_unix, unixTests);
    await runReplTests(socket, prompt_unix, errorTests);
    replServer.replMode = repl.REPL_MODE_STRICT;
    await runReplTests(socket, prompt_unix, strictModeTests);

    socket.end();
  }
  {
    const [ socket ] = await startTCPRepl();

    await runReplTests(socket, prompt_tcp, tcpTests);

    socket.end();
  }
  common.allowGlobals(globalThis.invoke_me, globalThis.message, globalThis.a, globalThis.blah,
                      globalThis.I, globalThis.f, globalThis.path, globalThis.x, globalThis.name, globalThis.foo);
})().then(common.mustCall());

function startTCPRepl() {
  let resolveSocket, resolveReplServer;

  const server = net.createServer(common.mustCall((socket) => {
    assert.strictEqual(server, socket.server);

    socket.on('end', common.mustCall(() => {
      socket.end();
    }));

    resolveReplServer(repl.start(prompt_tcp, socket));
  }));

  server.listen(0, common.mustCall(() => {
    const client = net.createConnection(server.address().port);

    client.setEncoding('utf8');

    client.on('connect', common.mustCall(() => {
      assert.strictEqual(client.readable, true);
      assert.strictEqual(client.writable, true);

      resolveSocket(client);
    }));

    client.on('close', common.mustCall(() => {
      server.close();
    }));
  }));

  return Promise.all([
    new Promise((resolve) => resolveSocket = resolve),
    new Promise((resolve) => resolveReplServer = resolve),
  ]);
}

function startUnixRepl() {
  let resolveSocket, resolveReplServer;

  const server = net.createServer(common.mustCall((socket) => {
    assert.strictEqual(server, socket.server);

    socket.on('end', common.mustCall(() => {
      socket.end();
    }));

    const replServer = repl.start({
      prompt: prompt_unix,
      input: socket,
      output: socket,
      useGlobal: true
    });
    replServer.context.message = message;
    resolveReplServer(replServer);
  }));

  tmpdir.refresh();

  server.listen(common.PIPE, common.mustCall(() => {
    const client = net.createConnection(common.PIPE);

    client.setEncoding('utf8');

    client.on('connect', common.mustCall(() => {
      assert.strictEqual(client.readable, true);
      assert.strictEqual(client.writable, true);

      resolveSocket(client);
    }));

    client.on('close', common.mustCall(() => {
      server.close();
    }));
  }));

  return Promise.all([
    new Promise((resolve) => resolveSocket = resolve),
    new Promise((resolve) => resolveReplServer = resolve),
  ]);
}

function event(ee, expected) {
  return new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      const data = inspect(expected, { compact: false });
      const msg = `The REPL did not reply as expected for:\n\n${data}`;
      reject(new Error(msg));
    }, common.platformTimeout(9999));
    ee.once('data', common.mustCall((...args) => {
      clearTimeout(timeout);
      resolve(...args);
    }));
  });
}