separate tests and validate they do what they should

Author: pipobscure

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

@@ -0,0 +1,65 @@
+'use strict';
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const { watch, readFile, writeFile } = require('fs/promises');
+const fs = require('fs');
+const assert = require('assert');
+const { join } = require('path');
+const { setTimeout } = require('timers/promises');
+const tmpdir = require('../common/tmpdir');
+
+class WatchTestCase {
+  constructor(shouldInclude, dirName, files) {
+    this.dirName = dirName;
+    this.files = files;
+    this.shouldSkip = !shouldInclude;
+  }
+  get dirPath() { return tmpdir.resolve(this.dirName); }
+  filePath(fileName) { return join(this.dirPath, fileName); }
+
+  async run() {
+    if (common.isMacOS) {
+      // On macOS delay watcher start to avoid leaking previous events.
+      // Refs: https://github.com/libuv/libuv/pull/4503
+      await setTimeout(common.platformTimeout(100));
+    }
+    await Promise.all([this.watchFiles(), this.writeFiles()]);
+    assert(!this.files.length);
+  }
+  async watchFiles() {
+    const watcher = watch(this.dirPath);
+    for await (const evt of watcher) {
+      const idx = this.files.indexOf(evt.filename);
+      if (idx < 0) continue;
+      this.files.splice(idx, 1);
+      await setTimeout(common.platformTimeout(100));
+      if (!this.files.length) break;
+    }
+  }
+  async writeFiles() {
+    for (const fileName of [...this.files]) {
+      await writeFile(this.filePath(fileName), Date.now() + fileName.repeat(1e4));
+    }
+    await setTimeout(common.platformTimeout(100));
+  }
+}
+
+const kCases = [
+  // Watch on a directory should callback with a filename on supported systems
+  new WatchTestCase(
+    common.isLinux || common.isMacOS || common.isWindows || common.isAIX,
+    'watch1',
+    ['foo', 'bar', 'baz']
+  )
+];
+
+tmpdir.refresh();
+
+for (const testCase of kCases) {
+  if (testCase.shouldSkip) continue;
+  fs.mkdirSync(testCase.dirPath);
+  testCase.run().then(common.mustCall());
+}

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

@@ -12,16 +12,14 @@ const { setTimeout } = require('timers/promises');
 const tmpdir = require('../common/tmpdir');
 
 class WatchTestCase {
-  constructor(shouldInclude, dirName, fileName, secondFileName, field) {
+  constructor(shouldInclude, dirName, fileName, field) {
     this.dirName = dirName;
     this.fileName = fileName;
-    this.secondFileName = secondFileName;
     this.field = field;
     this.shouldSkip = !shouldInclude;
   }
   get dirPath() { return tmpdir.resolve(this.dirName); }
   get filePath() { return join(this.dirPath, this.fileName); }
-  get secondFilePath() { return join(this.dirPath, this.secondFileName); }
 }
 
 const kCases = [
@@ -30,23 +28,13 @@ const kCases = [
     common.isLinux || common.isMacOS || common.isWindows || common.isAIX,
     'watch1',
     'foo',
-    undefined,
     'filePath'
   ),
   // Watch on a file should callback with a filename on supported systems
   new WatchTestCase(
     common.isLinux || common.isMacOS || common.isWindows,
     'watch2',
     'bar',
-    undefined,
-    'dirPath'
-  ),
-  // Watch a path and ensure that no files are missed
-  new WatchTestCase(
-    common.isLinux || common.isMacOS || common.isWindows || common.isAIX,
-    'watch3',
-    'foo',
-    'bar',
     'dirPath'
   ),
 ];
@@ -59,11 +47,6 @@ for (const testCase of kCases) {
   // Long content so it's actually flushed.
   const content1 = Date.now() + testCase.fileName.toLowerCase().repeat(1e4);
   fs.writeFileSync(testCase.filePath, content1);
-  if (testCase.secondFileName) {
-    const content2 = Date.now() + testCase.secondFileName.toLowerCase().repeat(1e4);
-    fs.writeFileSync(testCase.secondFilePath, content2);
-  }
-
 
   let interval;
   async function test() {
@@ -74,19 +57,11 @@ for (const testCase of kCases) {
     }
 
     const watcher = watch(testCase[testCase.field]);
-    let second = false;
     for await (const { eventType, filename } of watcher) {
-      if (!second) {
-        clearInterval(interval);
-        assert.strictEqual(['rename', 'change'].includes(eventType), true);
-        assert.strictEqual(filename, testCase.fileName);
-        second = true;
-        if (!testCase.secondFileName) break;
-      } else {
-        assert.strictEqual(['rename', 'change'].includes(eventType), true);
-        assert.strictEqual(filename, testCase.secondFileName);
-        break;
-      }
+      clearInterval(interval);
+      assert.strictEqual(['rename', 'change'].includes(eventType), true);
+      assert.strictEqual(filename, testCase.fileName);
+      break;
     }
 
     // Waiting on it again is a non-op