fs: improve argument handling for ReadStream

doc/api/fs.md

@@ -1291,6 +1291,11 @@ fs.copyFileSync('source.txt', 'destination.txt', COPYFILE_EXCL);
 <!-- YAML
 added: v0.1.31
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/19898
+    description: Impose new restrictions on `start` and `end`, throwing
+                 more appropriate errors in cases when we cannot reasonably
+                 handle the input values.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using

lib/fs.js

@@ -2014,30 +2014,49 @@ function ReadStream(path, options) {
   this.closed = false;
 
   if (this.start !== undefined) {
-    if (typeof this.start !== 'number' || Number.isNaN(this.start)) {
+    if (typeof this.start !== 'number') {
       throw new ERR_INVALID_ARG_TYPE('start', 'number', this.start);
     }
-    if (this.end === undefined) {
-      this.end = Infinity;
-    } else if (typeof this.end !== 'number' || Number.isNaN(this.end)) {
-      throw new ERR_INVALID_ARG_TYPE('end', 'number', this.end);
+
+    if (Number.isNaN(this.start)) {
+      throw new ERR_OUT_OF_RANGE('start', 'not NaN', this.start);
     }
 
-    if (this.start > this.end) {
-      const errVal = `{start: ${this.start}, end: ${this.end}}`;
-      throw new ERR_OUT_OF_RANGE('start', '<= "end"', errVal);
+    if (this.start < 0) {
+      throw new ERR_OUT_OF_RANGE('start', 'positive', this.start);
+    }
+
+    if (!Number.isInteger(this.start)) {
+      throw new ERR_OUT_OF_RANGE('start', 'integer', this.start);
     }
 
     this.pos = this.start;
   }
 
-  // Backwards compatibility: Make sure `end` is a number regardless of `start`.
-  // TODO(addaleax): Make the above typecheck not depend on `start` instead.
-  // (That is a semver-major change).
-  if (typeof this.end !== 'number')
+  if (this.end === undefined || this.end === Infinity) {
     this.end = Infinity;
-  else if (Number.isNaN(this.end))
-    throw new ERR_INVALID_ARG_TYPE('end', 'number', this.end);
+  } else {
+    if (typeof this.end !== 'number') {
+      throw new ERR_INVALID_ARG_TYPE('end', 'number', this.end);
+    }
+
+    if (Number.isNaN(this.end)) {
+      throw new ERR_OUT_OF_RANGE('end', 'not NaN', this.end);
+    }
+
+    if (this.end < 0) {
+      throw new ERR_OUT_OF_RANGE('end', 'positive', this.end);
+    }
+
+    if (!Number.isInteger(this.end)) {
+      throw new ERR_OUT_OF_RANGE('end', 'integer', this.end);
+    }
+
+    if (this.start !== undefined && this.start > this.end) {
+      const errVal = `{start: ${this.start}, end: ${this.end}}`;
+      throw new ERR_OUT_OF_RANGE('start', '<= "end"', errVal);
+    }
+  }
 
   if (typeof this.fd !== 'number')
     this.open();

test/parallel/test-fs-read-stream-throw-type-error.js

@@ -13,23 +13,54 @@ fs.createReadStream(example, null);
 fs.createReadStream(example, 'utf8');
 fs.createReadStream(example, { encoding: 'utf8' });
 
-const createReadStreamErr = (path, opt) => {
-  common.expectsError(
-    () => {
-      fs.createReadStream(path, opt);
-    },
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
+const createReadStreamErr = (path, opt, error) => {
+  common.expectsError(() => {
+    fs.createReadStream(path, opt);
+  }, error);
 };
 
-createReadStreamErr(example, 123);
-createReadStreamErr(example, 0);
-createReadStreamErr(example, true);
-createReadStreamErr(example, false);
+const typeError = {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
+};
+
+const rangeError = {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError
+};
+
+createReadStreamErr(example, 123, typeError);
+createReadStreamErr(example, 0, typeError);
+createReadStreamErr(example, true, typeError);
+createReadStreamErr(example, false, typeError);
+
+// Case 0: Should not throw if either start or end is undefined
+fs.createReadStream(example, {});
+fs.createReadStream(example, { start: 0 });
+fs.createReadStream(example, { end: Infinity });
+
+// Case 1: Should throw TypeError if either start or end is not of type 'number'
+createReadStreamErr(example, { start: 'invalid' }, typeError);
+createReadStreamErr(example, { end: 'invalid' }, typeError);
+createReadStreamErr(example, { start: 'invalid', end: 'invalid' }, typeError);
+
+// Case 2: Should throw RangeError if either start or end is NaN
+createReadStreamErr(example, { start: NaN }, rangeError);
+createReadStreamErr(example, { end: NaN }, rangeError);
+createReadStreamErr(example, { start: NaN, end: NaN }, rangeError);
+
+// Case 3: Should throw RangeError if either start or end is negative
+createReadStreamErr(example, { start: -1 }, rangeError);
+createReadStreamErr(example, { end: -1 }, rangeError);
+createReadStreamErr(example, { start: -1, end: -1 }, rangeError);
+
+// Case 4: Should throw RangeError if either start or end is fractional
+createReadStreamErr(example, { start: 0.1 }, rangeError);
+createReadStreamErr(example, { end: 0.1 }, rangeError);
+createReadStreamErr(example, { start: 0.1, end: 0.1 }, rangeError);
+
+// Case 5: Should not throw if both start and end are whole numbers
+fs.createReadStream(example, { start: 1, end: 5 });
 
-// createReadSteam _should_ throw on NaN
-createReadStreamErr(example, { start: NaN });
-createReadStreamErr(example, { end: NaN });
-createReadStreamErr(example, { start: NaN, end: NaN });
+// Case 6: Should throw RangeError if start is greater than end
+createReadStreamErr(example, { start: 5, end: 1 }, rangeError);