incorporate review and fix failing test

lib/internal/fetch/headers.js

@@ -9,15 +9,16 @@ const {
 } = require('internal/errors');
 
 const {
-  Array,
   ArrayIsArray,
+  ArrayPrototypeSplice,
   MathFloor,
   ObjectEntries,
   RegExpPrototypeSymbolReplace,
   StringPrototypeLocaleCompare,
   StringPrototypeToLocaleLowerCase,
   Symbol,
-  SymbolIterator
+  SymbolIterator,
+  ObjectDefineProperties
 } = primordials;
 
 const { validateObject } = require('internal/validators');
@@ -77,8 +78,12 @@ function normalizeAndValidateHeaderValue(name, value) {
   return normalizedHeaderValue;
 }
 
+function isHeaders (object) {
+  return kHeadersList in object
+}
+
 function fill(headers, object) {
-  if (kHeadersList in object) {
+  if (isHeaders(object)) {
     // Object is instance of Headers
     headers[kHeadersList] = ArrayPrototypeSlice(object[kHeadersList]);
   } else if (ArrayIsArray(object)) {
@@ -87,7 +92,7 @@ function fill(headers, object) {
       // Array of arrays
       for (let i = 0; i < object.length; i++) {
         if (object[i].length !== 2) {
-          throw new ERR_INVALID_ARG_VALUE('init', header,
+          throw new ERR_INVALID_ARG_VALUE('init', object[i],
                                           'is not of length 2');
         }
         headers.append(object[i][0], object[i][1]);
@@ -123,12 +128,22 @@ function fill(headers, object) {
 
 class Headers {
   constructor(init = {}) {
+    // fail silently on primitives
+    const typeofInit = typeof init
+    if (typeofInit === 'number'
+     || typeofInit === 'string'
+     || typeofInit === 'boolean'
+     || typeofInit === 'function' ) return
     validateObject(init, 'init', { allowArray: true });
     this[kHeadersList] = [];
     fill(this, init);
   }
 
   append(name, value) {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     const normalizedName = normalizeAndValidateHeaderName(name);
     const normalizedValue = normalizeAndValidateHeaderValue(name, value);
 
@@ -137,21 +152,29 @@ class Headers {
     if (this[kHeadersList][index] === normalizedName) {
       this[kHeadersList][index + 1] += `, ${normalizedValue}`;
     } else {
-      this[kHeadersList].splice(index, 0, normalizedName, normalizedValue);
+      ArrayPrototypeSplice(this[kHeadersList], index, 0, normalizedName, normalizedValue);
     }
   }
 
   delete(name) {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     const normalizedName = normalizeAndValidateHeaderName(name);
 
     const index = binarySearch(this[kHeadersList], normalizedName);
 
     if (this[kHeadersList][index] === normalizedName) {
-      this[kHeadersList].splice(index, 2);
+      ArrayPrototypeSplice(this[kHeadersList], index, 2);
     }
   }
 
   get(name) {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     const normalizedName = normalizeAndValidateHeaderName(name);
 
     const index = binarySearch(this[kHeadersList], normalizedName);
@@ -164,6 +187,10 @@ class Headers {
   }
 
   has(name) {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     const normalizedName = normalizeAndValidateHeaderName(name);
 
     const index = binarySearch(this[kHeadersList], normalizedName);
@@ -172,36 +199,56 @@ class Headers {
   }
 
   set(name, value) {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     const normalizedName = normalizeAndValidateHeaderName(name);
     const normalizedValue = normalizeAndValidateHeaderValue(name, value);
 
     const index = binarySearch(this[kHeadersList], normalizedName);
     if (this[kHeadersList][index] === normalizedName) {
       this[kHeadersList][index + 1] = normalizedValue;
     } else {
-      this[kHeadersList].splice(index, 0, normalizedName, normalizedValue);
+      ArrayPrototypeSplice(this[kHeadersList], index, 0, normalizedName, normalizedValue);
     }
   }
 
   * keys() {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     for (let index = 0; index < this[kHeadersList].length; index += 2) {
       yield this[kHeadersList][index];
     }
   }
 
   * values() {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     for (let index = 1; index < this[kHeadersList].length; index += 2) {
       yield this[kHeadersList][index];
     }
   }
 
   * entries() {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     for (let index = 0; index < this[kHeadersList].length; index += 2) {
       yield [this[kHeadersList][index], this[kHeadersList][index + 1]];
     }
   }
 
   forEach(callback, thisArg) {
+    if (!isHeaders(this)) {
+      throw new ERR_INVALID_THIS('Headers');
+    }
+
     for (let index = 0; index < this[kHeadersList].length; index += 2) {
       callback.call(
         thisArg,
@@ -215,6 +262,18 @@ class Headers {
 
 Headers.prototype[SymbolIterator] = Headers.prototype.entries;
 
+ObjectDefineProperties(Headers.prototype, {
+  append: { enumerable: true },
+  delete: { enumerable: true },
+  get: { enumerable: true },
+  has: { enumerable: true },
+  set: { enumerable: true },
+  keys: { enumerable: true },
+  values: { enumerable: true },
+  entries: { enumerable: true },
+  forEach: { enumerable: true },
+});
+
 module.exports = {
   Headers,
   binarySearch,

test/parallel/test-headers.js

@@ -98,6 +98,7 @@ const {
     function() {},
     1,
     'test',
+    true
   ].forEach((arg) => new Headers(arg));
 }