fs: adjust truncate mode from r+ to a

Author: LiviaMedeiros

doc/api/fs.md

@@ -591,7 +591,9 @@ try {
 ```
 
 If the file previously was shorter than `len` bytes, it is extended, and the
-extended part is filled with null bytes (`'\0'`):
+extended part is filled with null bytes (`'\0'`).
+
+If the file didn't exist, it is created.
 
 If `len` is negative then `0` will be used.
 

lib/fs.js

@@ -1053,7 +1053,7 @@ function truncate(path, len, callback) {
   validateInteger(len, 'len');
   len = MathMax(0, len);
   callback = maybeCallback(callback);
-  fs.open(path, 'r+', (er, fd) => {
+  fs.open(path, 'a', (er, fd) => {
     if (er) return callback(er);
     const req = new FSReqCallback();
     req.oncomplete = function oncomplete(er) {
@@ -1081,7 +1081,7 @@ function truncateSync(path, len) {
     len = 0;
   }
   // Allow error to be thrown, but still close fd.
-  const fd = fs.openSync(path, 'r+');
+  const fd = fs.openSync(path, 'a');
   let ret;
 
   try {

lib/internal/fs/promises.js

@@ -632,7 +632,7 @@ async function rename(oldPath, newPath) {
 }
 
 async function truncate(path, len = 0) {
-  const fd = await open(path, 'r+');
+  const fd = await open(path, 'a');
   return handleFdClose(ftruncate(fd, len), fd.close);
 }
 

test/parallel/test-fs-truncate-nonreadable.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const common = require('../common');
+
+// This test ensures that truncate works on non-readable files
+
+const assert = require('assert');
+const fs = require('fs');
+const fsPromises = fs.promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const expected = Buffer.from('good');
+
+function checkContents(filepath) {
+  fs.chmodSync(filepath, 0o400);
+  assert.deepStrictEqual(
+    fs.readFileSync(filepath),
+    expected
+  );
+}
+
+(async () => {
+  const MODE = 0o200;
+  {
+    const filepath = path.resolve(tmpdir.path, 'promises.txt');
+    fs.writeFileSync(filepath, 'good bad');
+    fs.chmodSync(filepath, MODE);
+    await fsPromises.truncate(filepath, 4);
+    checkContents(filepath);
+  }
+  {
+    const filepath = path.resolve(tmpdir.path, 'callback.txt');
+    fs.writeFileSync(filepath, 'good bad');
+    fs.chmodSync(filepath, MODE);
+    fs.truncate(filepath, 4, common.mustSucceed(() => {
+      checkContents(filepath);
+    }));
+  }
+  {
+    const filepath = path.resolve(tmpdir.path, 'synchronous.txt');
+    fs.writeFileSync(filepath, 'good bad');
+    fs.chmodSync(filepath, MODE);
+    fs.truncateSync(filepath, 4);
+    checkContents(filepath);
+  }
+})().then(common.mustCall());

test/parallel/test-fs-truncate.js

@@ -242,17 +242,17 @@ function testFtruncate(cb) {
 }
 
 {
-  const file8 = path.resolve(tmp, 'non-existent-truncate-file.txt');
-  const validateError = (err) => {
-    assert.strictEqual(file8, err.path);
-    assert.strictEqual(
-      err.message,
-      `ENOENT: no such file or directory, open '${file8}'`);
-    assert.strictEqual(err.code, 'ENOENT');
-    assert.strictEqual(err.syscall, 'open');
-    return true;
-  };
-  fs.truncate(file8, 0, common.mustCall(validateError));
+  const file8 = path.resolve(tmp, 'non-existent-truncate-file-1.txt');
+  fs.truncate(file8, 0, common.mustSucceed(() => {
+    assert(fs.readFileSync(file8).equals(Buffer.from('')));
+  }));
+}
+
+{
+  const file9 = path.resolve(tmp, 'non-existent-truncate-file-2.txt');
+  fs.truncate(file9, 2, common.mustSucceed(() => {
+    assert(fs.readFileSync(file9).equals(Buffer.from('\u0000\u0000')));
+  }));
 }
 
 ['', false, null, {}, []].forEach((input) => {