test: refactor repl tab complete tests

refactor the test/parallel/test-repl-tab-complete.js file by:
- making the tests in the file self-contained
(instead of all of them sharing the same REPL instance and
constantly calling `.clear` on it)
- using the test runner with appropriate descriptions to make
clearer what is being tested
- extracting some tests in their own js test files
(to increase isolation of the tests and help with issues such
as flakiness)
PR-URL: #58636
Reviewed-By: Giovanni Bucci <github@puskin.it>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: dario-piotrowicz

test/parallel/test-repl-tab-complete-buffer.js

@@ -0,0 +1,73 @@
+'use strict';
+
+constcommon=require('../common');
+constArrayStream=require('../common/arraystream');
+const{ hijackStderr, restoreStderr }=require('../common/hijackstdio');
+constassert=require('assert');
+
+constrepl=require('repl');
+
+constinput=newArrayStream();
+constreplServer=repl.start({
+prompt: '',
+ input,
+output: process.stdout,
+allowBlockingCompletions: true,
+});
+
+// Some errors are passed to the domain, but do not callback
+replServer._domain.on('error',assert.ifError);
+
+for(consttypeof[
+Array,
+Buffer,
+
+Uint8Array,
+Uint16Array,
+Uint32Array,
+
+Uint8ClampedArray,
+Int8Array,
+Int16Array,
+Int32Array,
+Float32Array,
+Float64Array,
+]){
+input.run(['.clear']);
+
+if(type===Array){
+input.run([
+'var ele = [];',
+'for (let i = 0; i < 1e6 + 1; i++) ele[i] = 0;',
+'ele.biu = 1;',
+]);
+}elseif(type===Buffer){
+input.run(['var ele = Buffer.alloc(1e6 + 1); ele.biu = 1;']);
+}else{
+input.run([`var ele = new ${type.name}(1e6 + 1); ele.biu = 1;`]);
+}
+
+hijackStderr(common.mustNotCall());
+replServer.complete(
+'ele.',
+common.mustCall((err,data)=>{
+restoreStderr();
+assert.ifError(err);
+
+constele=
+type===Array ? [] : type===Buffer ? Buffer.alloc(0) : newtype(0);
+
+assert.strictEqual(data[0].includes('ele.biu'),true);
+
+data[0].forEach((key)=>{
+if(!key||key==='ele.biu')return;
+assert.notStrictEqual(ele[key.slice(4)],undefined);
+});
+})
+);
+}
+
+// check Buffer.prototype.length not crashing.
+// Refs: https://github.com/nodejs/node/pull/11961
+input.run(['.clear']);
+replServer.complete('Buffer.prototype.',common.mustCall());

test/parallel/test-repl-tab-complete-custom-completer.js

@@ -0,0 +1,75 @@
+'use strict';
+
+constcommon=require('../common');
+constArrayStream=require('../common/arraystream');
+constassert=require('assert');
+
+constrepl=require('repl');
+
+constputIn=newArrayStream();
+
+// To test custom completer function.
+// Sync mode.
+{
+constcustomCompletions='aaa aa1 aa2 bbb bb1 bb2 bb3 ccc ddd eee'.split(' ');
+consttestCustomCompleterSyncMode=repl.start({
+prompt: '',
+input: putIn,
+output: putIn,
+completer: functioncompleter(line){
+consthits=customCompletions.filter((c)=>c.startsWith(line));
+// Show all completions if none found.
+return[hits.length ? hits : customCompletions,line];
+}
+});
+
+// On empty line should output all the custom completions
+// without complete anything.
+testCustomCompleterSyncMode.complete('',common.mustCall((error,data)=>{
+assert.deepStrictEqual(data,[
+customCompletions,
+'',
+]);
+}));
+
+// On `a` should output `aaa aa1 aa2` and complete until `aa`.
+testCustomCompleterSyncMode.complete('a',common.mustCall((error,data)=>{
+assert.deepStrictEqual(data,[
+'aaa aa1 aa2'.split(' '),
+'a',
+]);
+}));
+}
+
+// To test custom completer function.
+// Async mode.
+{
+constcustomCompletions='aaa aa1 aa2 bbb bb1 bb2 bb3 ccc ddd eee'.split(' ');
+consttestCustomCompleterAsyncMode=repl.start({
+prompt: '',
+input: putIn,
+output: putIn,
+completer: functioncompleter(line,callback){
+consthits=customCompletions.filter((c)=>c.startsWith(line));
+// Show all completions if none found.
+callback(null,[hits.length ? hits : customCompletions,line]);
+}
+});
+
+// On empty line should output all the custom completions
+// without complete anything.
+testCustomCompleterAsyncMode.complete('',common.mustCall((error,data)=>{
+assert.deepStrictEqual(data,[
+customCompletions,
+'',
+]);
+}));
+
+// On `a` should output `aaa aa1 aa2` and complete until `aa`.
+testCustomCompleterAsyncMode.complete('a',common.mustCall((error,data)=>{
+assert.deepStrictEqual(data,[
+'aaa aa1 aa2'.split(' '),
+'a',
+]);
+}));
+}

test/parallel/test-repl-tab-complete-files.js

@@ -0,0 +1,80 @@
+'use strict';
+
+constcommon=require('../common');
+constArrayStream=require('../common/arraystream');
+constassert=require('assert');
+constpath=require('path');
+
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('process.chdir is not available in Workers');
+}
+
+constrepl=require('repl');
+
+constreplServer=repl.start({
+prompt: '',
+input: newArrayStream(),
+output: process.stdout,
+allowBlockingCompletions: true,
+});
+
+// Some errors are passed to the domain, but do not callback
+replServer._domain.on('error',assert.ifError);
+
+// Tab completion for files/directories
+{
+process.chdir(__dirname);
+
+constreadFileSyncs=['fs.readFileSync("','fs.promises.readFileSync("'];
+if(!common.isWindows){
+readFileSyncs.forEach((readFileSync)=>{
+constfixturePath=`${readFileSync}../fixtures/test-repl-tab-completion`;
+replServer.complete(
+fixturePath,
+common.mustCall((err,data)=>{
+assert.strictEqual(err,null);
+assert.ok(data[0][0].includes('.hiddenfiles'));
+assert.ok(data[0][1].includes('hellorandom.txt'));
+assert.ok(data[0][2].includes('helloworld.js'));
+})
+);
+
+replServer.complete(
+`${fixturePath}/hello`,
+common.mustCall((err,data)=>{
+assert.strictEqual(err,null);
+assert.ok(data[0][0].includes('hellorandom.txt'));
+assert.ok(data[0][1].includes('helloworld.js'));
+})
+);
+
+replServer.complete(
+`${fixturePath}/.h`,
+common.mustCall((err,data)=>{
+assert.strictEqual(err,null);
+assert.ok(data[0][0].includes('.hiddenfiles'));
+})
+);
+
+replServer.complete(
+`${readFileSync}./xxxRandom/random`,
+common.mustCall((err,data)=>{
+assert.strictEqual(err,null);
+assert.strictEqual(data[0].length,0);
+})
+);
+
+consttestPath=fixturePath.slice(0,-1);
+replServer.complete(
+testPath,
+common.mustCall((err,data)=>{
+assert.strictEqual(err,null);
+assert.ok(data[0][0].includes('test-repl-tab-completion'));
+assert.strictEqual(data[1],path.basename(testPath));
+})
+);
+});
+}
+}

test/parallel/test-repl-tab-complete-on-editor-mode.js

@@ -1,21 +1,48 @@
 'use strict';
 
-require('../common');
+constcommon=require('../common');
+constassert=require('assert');
 constArrayStream=require('../common/arraystream');
 constrepl=require('repl');
 
-conststream=newArrayStream();
-constreplServer=repl.start({
-input: stream,
-output: stream,
-terminal: true,
-});
+// Tab completion in editor mode
+{
+consteditorStream=newArrayStream();
+consteditor=repl.start({
+stream: editorStream,
+terminal: true,
+useColors: false
+});
 
-// Editor mode
-replServer.write('.editor\n');
+editorStream.run(['.clear']);
+editorStream.run(['.editor']);
+
+editor.completer('Uin',common.mustCall((_error,data)=>{
+assert.deepStrictEqual(data,[['Uint'],'Uin']);
+}));
+
+editorStream.run(['.clear']);
+editorStream.run(['.editor']);
+
+editor.completer('var log = console.l',common.mustCall((_error,data)=>{
+assert.deepStrictEqual(data,[['console.log'],'console.l']);
+}));
+}
 
 // Regression test for https://github.com/nodejs/node/issues/43528
-replServer.write('a');
-replServer.write(null,{name: 'tab'});// Should not throw
+{
+conststream=newArrayStream();
+constreplServer=repl.start({
+input: stream,
+output: stream,
+terminal: true,
+});
+
+// Editor mode
+replServer.write('.editor\n');
+
+replServer.write('a');
+replServer.write(null,{name: 'tab'});// Should not throw
 
-replServer.close();
+replServer.close();
+}