squash: add test for fs.write()

Author: LiviaMedeiros

test/parallel/test-fs-write-optional-params.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const common = require('../common');
+
+// This test ensures that fs.write accepts "named parameters" object
+// and doesn't interpret objects as strings
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+const destInvalid = path.resolve(tmpdir.path, 'rwopt_invalid');
+const buffer = Buffer.from('zyx');
+
+async function testInvalid(fd, expectedCode, ...params) {
+  assert.throws(
+    () => fs.write(fd, ...params, common.mustNotCall()),
+    { code: expectedCode }
+  );
+}
+
+function testValid([ buffer, options ], index) {
+  const dest = path.resolve(tmpdir.path, `rwopt_valid_${index}`);
+  fs.open(dest, 'w+', common.mustSucceed((fd) => {
+    fs.write(fd, buffer, options, common.mustSucceed((bytesWritten, bufferWritten) => {
+      const writeBufCopy = Uint8Array.prototype.slice.call(bufferWritten);
+
+      // TODO: replace this with fs.read(fd, buffer, options, cb) if it is supported
+      fs.read(fd, { buffer, ...options }, common.mustSucceed((bytesRead, bufferRead) => {
+        const readBufCopy = Uint8Array.prototype.slice.call(bufferRead);
+
+        assert.ok(bytesWritten >= bytesRead);
+        if (options.length !== undefined && options.length !== null) {
+          assert.strictEqual(bytesWritten, options.length);
+        }
+        if (options.offset === undefined || options.offset === 0) {
+          assert.deepStrictEqual(writeBufCopy, readBufCopy);
+        }
+        assert.deepStrictEqual(bufferWritten, bufferRead);
+        fs.close(fd, common.mustSucceed());
+      }));
+    }));
+  }));
+}
+
+fs.open(destInvalid, 'w+', common.mustSucceed((fd) => {
+  // Test if first argument is not wrongly interpreted as ArrayBufferView|string
+  for (const badBuffer of [
+    undefined, null, true, 42, 42n, Symbol('42'), NaN, [], () => {},
+    Promise.resolve(new Uint8Array(1)),
+    {},
+    { buffer: 'amNotParam' },
+    { string: 'amNotParam' },
+    { buffer: new Uint8Array(1).buffer },
+    new Date(),
+    new String('notPrimitive'),
+    { [Symbol.toPrimitive]: (hint) => 'amObject' },
+
+    // TODO: add the following after DEP0162 EOL
+    // { toString() { return 'amObject'; } },
+  ]) {
+    testInvalid(fd, 'ERR_INVALID_ARG_TYPE', badBuffer, {});
+  }
+
+  // First argument (buffer or string) is mandatory
+  testInvalid(fd, 'ERR_INVALID_ARG_TYPE');
+
+  // Various invalid options
+  testInvalid(fd, 'ERR_OUT_OF_RANGE', buffer, { length: 5 });
+  testInvalid(fd, 'ERR_OUT_OF_RANGE', buffer, { offset: 5 });
+  testInvalid(fd, 'ERR_OUT_OF_RANGE', buffer, { length: 1, offset: 3 });
+  testInvalid(fd, 'ERR_OUT_OF_RANGE', buffer, { length: -1 });
+  testInvalid(fd, 'ERR_OUT_OF_RANGE', buffer, { offset: -1 });
+  testInvalid(fd, 'ERR_INVALID_ARG_TYPE', buffer, { offset: false });
+  testInvalid(fd, 'ERR_INVALID_ARG_TYPE', buffer, { offset: true });
+
+  // Test compatibility with fs.read counterpart
+  [
+    [ buffer, {} ],
+    [ buffer, { length: 1 } ],
+    [ buffer, { position: 5 } ],
+    [ buffer, { length: 1, position: 5 } ],
+    [ buffer, { length: 1, position: -1, offset: 2 } ],
+    [ buffer, { length: null } ],
+    [ buffer, { position: null } ],
+    [ buffer, { offset: 1 } ],
+  ].forEach(testValid);
+}));