test: refactor fs-watch tests due to macOS issue

In `macOS`, fsevents generated immediately before start watching may
leak into the event callback. See: #54450
for an explanation. This might be fixed at some point in `libuv` though
it may take some time (see: libuv/libuv#3866).
This commit comes in anticipation of the soon-to-be-released
`libuv@1.49.0` which was making these tests very flaky.
PR-URL: #54498
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>

Author: santigimeno

test/parallel/test-fs-promises-watch.js

@@ -8,6 +8,7 @@ const { watch } = require('fs/promises');
 constfs=require('fs');
 constassert=require('assert');
 const{ join }=require('path');
+const{ setTimeout }=require('timers/promises');
 consttmpdir=require('../common/tmpdir');
 
 classWatchTestCase{
@@ -49,6 +50,12 @@ for (const testCase of kCases) {
 
 letinterval;
 asyncfunctiontest(){
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+awaitsetTimeout(common.platformTimeout(100));
+}
+
 constwatcher=watch(testCase[testCase.field]);
 forawait(const{ eventType, filename }ofwatcher){
 clearInterval(interval);

test/parallel/test-fs-watch-recursive-add-file-to-new-folder.js

@@ -31,24 +31,34 @@ const filePath = path.join(testDirectory, 'folder-3');
 constchildrenFile='file-4.txt';
 constchildrenAbsolutePath=path.join(filePath,childrenFile);
 constchildrenRelativePath=path.join(path.basename(filePath),childrenFile);
-
-constwatcher=fs.watch(testDirectory,{recursive: true});
 letwatcherClosed=false;
-watcher.on('change',function(event,filename){
-assert.strictEqual(event,'rename');
-assert.ok(filename===path.basename(filePath)||filename===childrenRelativePath);
-
-if(filename===childrenRelativePath){
-watcher.close();
-watcherClosed=true;
-}
-});
 
-// Do the write with a delay to ensure that the OS is ready to notify us.
-setTimeout(()=>{
-fs.mkdirSync(filePath);
-fs.writeFileSync(childrenAbsolutePath,'world');
-},common.platformTimeout(200));
+functiondoWatch(){
+constwatcher=fs.watch(testDirectory,{recursive: true});
+watcher.on('change',function(event,filename){
+assert.strictEqual(event,'rename');
+assert.ok(filename===path.basename(filePath)||filename===childrenRelativePath);
+
+if(filename===childrenRelativePath){
+watcher.close();
+watcherClosed=true;
+}
+});
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(()=>{
+fs.mkdirSync(filePath);
+fs.writeFileSync(childrenAbsolutePath,'world');
+},common.platformTimeout(200));
+}
+
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+setTimeout(doWatch,common.platformTimeout(100));
+}else{
+doWatch();
+}
 
 process.once('exit',function(){
 assert(watcherClosed,'watcher Object was not closed');

test/parallel/test-fs-watch-recursive-symlink.js

@@ -35,6 +35,11 @@ tmpdir.refresh();
 constsymlinkFolder=path.join(rootDirectory,'symlink-folder');
 fs.symlinkSync(rootDirectory,symlinkFolder);
 
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+awaitsetTimeout(common.platformTimeout(100));
+}
 
 constwatcher=fs.watch(rootDirectory,{recursive: true});
 letwatcherClosed=false;
@@ -74,6 +79,12 @@ tmpdir.refresh();
 constforbiddenFile=path.join(subDirectory,'forbidden.txt');
 constacceptableFile=path.join(trackingSubDirectory,'acceptable.txt');
 
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+awaitsetTimeout(common.platformTimeout(100));
+}
+
 constwatcher=fs.watch(trackingSubDirectory,{recursive: true});
 letwatcherClosed=false;
 watcher.on('change',function(event,filename){

test/parallel/test-fs-watch-recursive-sync-write.js

@@ -25,14 +25,24 @@ const keepalive = setTimeout(() => {
 thrownewError('timed out');
 },common.platformTimeout(30_000));
 
-constwatcher=watch(tmpDir,{recursive: true},common.mustCall((eventType,_filename)=>{
-clearTimeout(keepalive);
-watcher.close();
-assert.strictEqual(eventType,'rename');
-assert.strictEqual(join(tmpDir,_filename),filename);
-}));
-
-// Do the write with a delay to ensure that the OS is ready to notify us.
-setTimeout(()=>{
-writeFileSync(filename,'foobar2');
-},common.platformTimeout(200));
+functiondoWatch(){
+constwatcher=watch(tmpDir,{recursive: true},common.mustCall((eventType,_filename)=>{
+clearTimeout(keepalive);
+watcher.close();
+assert.strictEqual(eventType,'rename');
+assert.strictEqual(join(tmpDir,_filename),filename);
+}));
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(()=>{
+writeFileSync(filename,'foobar2');
+},common.platformTimeout(200));
+}
+
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+setTimeout(doWatch,common.platformTimeout(100));
+}else{
+doWatch();
+}

test/parallel/test-fs-watch.js

@@ -41,13 +41,7 @@ const cases = [
 consttmpdir=require('../common/tmpdir');
 tmpdir.refresh();
 
-for(consttestCaseofcases){
-if(testCase.shouldSkip)continue;
-fs.mkdirSync(testCase.dirPath);
-// Long content so it's actually flushed.
-constcontent1=Date.now()+testCase.fileName.toLowerCase().repeat(1e4);
-fs.writeFileSync(testCase.filePath,content1);
-
+functiondoWatchTest(testCase){
 letinterval;
 constpathToWatch=testCase[testCase.field];
 constwatcher=fs.watch(pathToWatch);
@@ -87,6 +81,23 @@ for (const testCase of cases) {
 },100);
 }
 
+for(consttestCaseofcases){
+if(testCase.shouldSkip)continue;
+fs.mkdirSync(testCase.dirPath);
+// Long content so it's actually flushed.
+constcontent1=Date.now()+testCase.fileName.toLowerCase().repeat(1e4);
+fs.writeFileSync(testCase.filePath,content1);
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+setTimeout(()=>{
+doWatchTest(testCase);
+},common.platformTimeout(100));
+}else{
+doWatchTest(testCase);
+}
+}
+
 [false,1,{},[],null,undefined].forEach((input)=>{
 assert.throws(
 ()=>fs.watch(input,common.mustNotCall()),

test/parallel/test-fs-watchfile.js

@@ -86,10 +86,7 @@ watcher.on('stop', common.mustCall());
 // Omitting AIX. It works but not reliably.
 if(common.isLinux||common.isMacOS||common.isWindows){
 constdir=tmpdir.resolve('watch');
-
-fs.mkdir(dir,common.mustCall(function(err){
-if(err)assert.fail(err);
-
+functiondoWatch(){
 consthandle=fs.watch(dir,common.mustCall(function(eventType,filename){
 clearInterval(interval);
 handle.close();
@@ -101,5 +98,15 @@ if (common.isLinux || common.isMacOS || common.isWindows) {
 if(err)assert.fail(err);
 }));
 },1);
+}
+
+fs.mkdir(dir,common.mustSucceed(()=>{
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+setTimeout(doWatch,common.platformTimeout(100));
+}else{
+doWatch();
+}
 }));
 }

test/pummel/test-fs-watch-non-recursive.js

@@ -38,14 +38,24 @@ const filepath = path.join(testsubdir, 'watch.txt');
 
 fs.mkdirSync(testsubdir,0o700);
 
-constwatcher=fs.watch(testDir,{persistent: true},(event,filename)=>{
-// This function may be called with the directory depending on timing but
-// must not be called with the file..
-assert.strictEqual(filename,'testsubdir');
-});
-setTimeout(()=>{
-fs.writeFileSync(filepath,'test');
-},100);
-setTimeout(()=>{
-watcher.close();
-},500);
+functiondoWatch(){
+constwatcher=fs.watch(testDir,{persistent: true},(event,filename)=>{
+// This function may be called with the directory depending on timing but
+// must not be called with the file..
+assert.strictEqual(filename,'testsubdir');
+});
+setTimeout(()=>{
+fs.writeFileSync(filepath,'test');
+},100);
+setTimeout(()=>{
+watcher.close();
+},500);
+}
+
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+setTimeout(doWatch,common.platformTimeout(100));
+}else{
+doWatch();
+}

test/sequential/test-fs-watch.js

@@ -95,24 +95,34 @@ function repeat(fn) {
 consttestsubdir=fs.mkdtempSync(testDir+path.sep);
 constfilepath=path.join(testsubdir,'newfile.txt');
 
-constwatcher=
-fs.watch(testsubdir,common.mustCall(function(event,filename){
-constrenameEv=common.isSunOS||common.isAIX ? 'change' : 'rename';
-assert.strictEqual(event,renameEv);
-if(expectFilePath){
-assert.strictEqual(filename,'newfile.txt');
-}else{
-assert.strictEqual(filename,null);
-}
-clearInterval(interval);
-watcher.close();
-}));
+functiondoWatch(){
+constwatcher=
+fs.watch(testsubdir,common.mustCall(function(event,filename){
+constrenameEv=common.isSunOS||common.isAIX ? 'change' : 'rename';
+assert.strictEqual(event,renameEv);
+if(expectFilePath){
+assert.strictEqual(filename,'newfile.txt');
+}else{
+assert.strictEqual(filename,null);
+}
+clearInterval(interval);
+watcher.close();
+}));
+
+constinterval=repeat(()=>{
+fs.rmSync(filepath,{force: true});
+constfd=fs.openSync(filepath,'w');
+fs.closeSync(fd);
+});
+}
 
-constinterval=repeat(()=>{
-fs.rmSync(filepath,{force: true});
-constfd=fs.openSync(filepath,'w');
-fs.closeSync(fd);
-});
+if(common.isMacOS){
+// On macOS delay watcher start to avoid leaking previous events.
+// Refs: https://github.com/libuv/libuv/pull/4503
+setTimeout(doWatch,common.platformTimeout(100));
+}else{
+doWatch();
+}
 }
 
 // https://github.com/joyent/node/issues/2293 - non-persistent watcher should