From ce7402d1bce61f5ea03f27336fff43b9a217cb41 Mon Sep 17 00:00:00 2001
From: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
Date: Sun, 12 Jul 2015 16:58:50 +0000
Subject: [PATCH] doc,test: note and test about non-existent files, in
 watchFile

As per the discussion in
/~https://github.com/nodejs/io.js/pull/2093#discussion_r34343965, this
patch improves the Note section in watchFile to clarify about the
non-existent files.

This patch also includes a test which checks if a file not present, the
callback is invoked at least once and if the file is created after
the callback is invoked, it will be invoked again with new stat
objects.

PR-URL: /~https://github.com/nodejs/io.js/pull/2169
---
 doc/api/fs.markdown                |  5 ++-
 test/parallel/test-fs-watchfile.js | 62 +++++++++++++++++++++++++++---
 2 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/doc/api/fs.markdown b/doc/api/fs.markdown
index 82841f0acf044a..5f96b10763fe45 100644
--- a/doc/api/fs.markdown
+++ b/doc/api/fs.markdown
@@ -577,7 +577,10 @@ If you want to be notified when the file was modified, not just accessed
 you need to compare `curr.mtime` and `prev.mtime`.
 
 _Note: when an `fs.watchFile` operation results in an `ENOENT` error, it will
-invoke the callback once. This is a change in functionality since v0.10._
+ invoke the listener once, with all the fields zeroed (or, for dates, the Unix
+ Epoch). In Windows, `blksize` and `blocks` fields will be `undefined`, instead
+ of zero. If the file is created later on, the listener will be called again,
+ with the latest stat objects. This is a change in functionality since v0.10._
 
 _Note: `fs.watch` is more efficient than `fs.watchFile` and `fs.unwatchFile`.
 `fs.watch` should be used instead of `fs.watchFile` and `fs.unwatchFile`
diff --git a/test/parallel/test-fs-watchfile.js b/test/parallel/test-fs-watchfile.js
index eacb2f9d821982..35712741f773df 100644
--- a/test/parallel/test-fs-watchfile.js
+++ b/test/parallel/test-fs-watchfile.js
@@ -1,9 +1,9 @@
 'use strict';
 
+const common = require('../common');
 const fs = require('fs');
 const path = require('path');
 const assert = require('assert');
-const common = require('../common');
 const fixtures = path.join(__dirname, '..', 'fixtures');
 
 // Basic usage tests.
@@ -19,8 +19,60 @@ assert.throws(function() {
   fs.watchFile(new Object(), function() {});
 }, /Path must be a string/);
 
-// Test ENOENT. Should fire once.
-const enoentFile = path.join(fixtures, 'empty', 'non-existent-file');
+const enoentFile = path.join(fixtures, 'non-existent-file');
+const expectedStatObject = new fs.Stats(
+    0,                                        // dev
+    0,                                        // mode
+    0,                                        // nlink
+    0,                                        // uid
+    0,                                        // gid
+    0,                                        // rdev
+    common.isWindows ? undefined : 0,         // blksize
+    0,                                        // ino
+    0,                                        // size
+    common.isWindows ? undefined : 0,         // blocks
+    Date.UTC(1970, 0, 1, 0, 0, 0),            // atime
+    Date.UTC(1970, 0, 1, 0, 0, 0),            // mtime
+    Date.UTC(1970, 0, 1, 0, 0, 0),            // ctime
+    Date.UTC(1970, 0, 1, 0, 0, 0)             // birthtime
+);
+
+function removeTestFile() {
+  try {
+    fs.unlinkSync(enoentFile);
+  } catch (ex) {
+    if (ex.code !== 'ENOENT') {
+      throw ex;
+    }
+  }
+}
+
+// Make sure that the file does not exist, when the test starts
+removeTestFile();
+
+// If the file initially didn't exist, and gets created at a later point of
+// time, the callback should be invoked again with proper values in stat object
+var fileExists = false;
+
 fs.watchFile(enoentFile, common.mustCall(function(curr, prev) {
-  fs.unwatchFile(enoentFile);
-}));
+  if (!fileExists) {
+    // If the file does not exist, all the fields should be zero and the date
+    // fields should be UNIX EPOCH time
+    assert.deepStrictEqual(curr, expectedStatObject);
+    assert.deepStrictEqual(prev, expectedStatObject);
+    // Create the file now, so that the callback will be called back once the
+    // event loop notices it.
+    fs.closeSync(fs.openSync(enoentFile, 'w'));
+    fileExists = true;
+  } else {
+    // If the ino (inode) value is greater than zero, it means that the file is
+    // present in the filesystem and it has a valid inode number.
+    assert(curr.ino > 0);
+    // As the file just got created, previous ino value should be lesser than
+    // or equal to zero (non-existent file).
+    assert(prev.ino <= 0);
+    // Stop watching the file and delete it
+    fs.unwatchFile(enoentFile);
+    removeTestFile();
+  }
+}, 2));