test: fix fs tests affected by optimizations

Author: mscdex

test/parallel/test-fs-read-stream-err.js

@@ -36,23 +36,23 @@ stream.on('error', common.mustCall((err_) => {
   }));
 }));
 
-fs.close = common.mustCall((fd_, cb) => {
-  assert.strictEqual(fd_, stream.fd);
-  process.nextTick(cb);
+process.binding('fs').close = common.mustCall((fd, req) => {
+  assert.strictEqual(fd, stream.fd);
+  process.nextTick(req.oncomplete.bind(req));
 });
 
-const read = fs.read;
-fs.read = function() {
+const read = process.binding('fs').read;
+process.binding('fs').read = function() {
   // first time is ok.
-  read.apply(fs, arguments);
+  read.apply(null, arguments);
   // then it breaks
-  fs.read = common.mustCall(function() {
-    const cb = arguments[arguments.length - 1];
+  process.binding('fs').read = common.mustCall(function() {
+    const req = arguments[arguments.length - 1];
     process.nextTick(() => {
-      cb(err);
+      req.oncomplete(err);
     });
     // and should not be called again!
-    fs.read = () => {
+    process.binding('fs').read = () => {
       throw new Error('BOOM!');
     };
   });

test/parallel/test-fs-sync-fd-leak.js

@@ -24,21 +24,20 @@ require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-// ensure that (read|write|append)FileSync() closes the file descriptor
-fs.openSync = function() {
+process.binding('fs').open = function() {
   return 42;
 };
-fs.closeSync = function(fd) {
+// ensure that (read|write|append)FileSync() closes the file descriptor
+process.binding('fs').close = function(fd) {
   assert.strictEqual(fd, 42);
   close_called++;
 };
-fs.readSync = function() {
+process.binding('fs').read = function() {
   throw new Error('BAM');
 };
-fs.writeSync = function() {
+process.binding('fs').writeBuffer = function() {
   throw new Error('BAM');
 };
-
 process.binding('fs').fstat = function() {
   throw new Error('BAM');
 };

test/parallel/test-fs-write-file-sync.js

@@ -28,12 +28,12 @@ let openCount = 0;
 let mode;
 let content;
 
-// Need to hijack fs.open/close to make sure that things
-// get closed once they're opened.
-fs._openSync = fs.openSync;
-fs.openSync = openSync;
-fs._closeSync = fs.closeSync;
-fs.closeSync = closeSync;
+// Need to hijack binding to make sure that things get closed once they're
+// opened.
+const open = process.binding('fs').open;
+process.binding('fs').open = openSync;
+const close = process.binding('fs').close;
+process.binding('fs').close = closeSync;
 
 // Reset the umask for testing
 process.umask(0o000);
@@ -85,10 +85,10 @@ assert.strictEqual(openCount, 0);
 
 function openSync() {
   openCount++;
-  return fs._openSync.apply(fs, arguments);
+  return open.apply(null, arguments);
 }
 
 function closeSync() {
   openCount--;
-  return fs._closeSync.apply(fs, arguments);
+  return close.apply(null, arguments);
 }

test/parallel/test-fs-write-stream-change-open.js

@@ -30,25 +30,24 @@ const file = path.join(common.tmpDir, 'write.txt');
 common.refreshTmpDir();
 
 const stream = fs.WriteStream(file);
-const _fs_close = fs.close;
-const _fs_open = fs.open;
-
-// change the fs.open with an identical function after the WriteStream
-// has pushed it onto its internal action queue, but before it's
-// returned.  This simulates AOP-style extension of the fs lib.
-fs.open = function() {
-  return _fs_open.apply(fs, arguments);
+const close = process.binding('fs').close;
+const open = process.binding('fs').open;
+
+// change the binding.open with an identical function after the WriteStream
+// has pushed it onto its internal action queue, but before it's returned.
+process.binding('fs').open = function() {
+  return open.apply(null, arguments);
 };
 
-fs.close = function(fd) {
+process.binding('fs').close = function(fd) {
   assert.ok(fd, 'fs.close must not be called with an undefined fd.');
-  fs.close = _fs_close;
-  fs.open = _fs_open;
+  process.binding('fs').close = close;
+  process.binding('fs').open = open;
 };
 
 stream.write('foo');
 stream.end();
 
 process.on('exit', function() {
-  assert.strictEqual(fs.open, _fs_open);
+  assert.strictEqual(process.binding('fs').open, open);
 });

test/parallel/test-fs-write-stream-err.js

@@ -31,44 +31,35 @@ const stream = fs.createWriteStream(common.tmpDir + '/out', {
 });
 const err = new Error('BAM');
 
-const write = fs.write;
+const writeBuffer = process.binding('fs').writeBuffer;
 let writeCalls = 0;
-fs.write = function() {
+process.binding('fs').writeBuffer = common.mustCall(function() {
   switch (writeCalls++) {
     case 0:
-      console.error('first write');
       // first time is ok.
-      return write.apply(fs, arguments);
+      return writeBuffer.apply(null, arguments);
     case 1:
       // then it breaks
-      console.error('second write');
-      const cb = arguments[arguments.length - 1];
+      const req = arguments[arguments.length - 1];
       return process.nextTick(function() {
-        cb(err);
+        req.oncomplete(err);
       });
-    default:
-      // and should not be called again!
-      throw new Error('BOOM!');
   }
-};
+}, 2);
 
-fs.close = common.mustCall(function(fd_, cb) {
-  console.error('fs.close', fd_, stream.fd);
-  assert.strictEqual(fd_, stream.fd);
-  process.nextTick(cb);
+process.binding('fs').close = common.mustCall(function(fd, req) {
+  assert.strictEqual(fd, stream.fd);
+  process.nextTick(req.oncomplete.bind(req));
 });
 
 stream.on('error', common.mustCall(function(err_) {
-  console.error('error handler');
   assert.strictEqual(stream.fd, null);
   assert.strictEqual(err_, err);
 }));
 
 
 stream.write(Buffer.allocUnsafe(256), function() {
-  console.error('first cb');
   stream.write(Buffer.allocUnsafe(256), common.mustCall(function(err_) {
-    console.error('second cb');
     assert.strictEqual(err_, err);
   }));
 });

test/parallel/test-npm-install.js

@@ -55,7 +55,7 @@ execFile(process.execPath, args, {
     const code = err.code;
     const signal = err.signal;
     stderr += '';
-    var msg = `npm install got error code ${code}\nstderr:\n${stderr}`;
+    let msg = `npm install got error code ${code}\nstderr:\n${stderr}`;
     assert.strictEqual(code, 0, msg);
     msg = `unexpected signal: ${signal}\nstderr:\n${stderr}`;
     assert.strictEqual(signal, null, msg);