Enable node error tests for on() and most for once()

src/js/internal/validators.ts

@@ -61,7 +61,7 @@ function validateLinkHeaderValue(hints) {
 hideFromStack(validateLinkHeaderValue);
 // TODO: do it in NodeValidator.cpp
 function validateObject(value, name) {
-  if (typeof value !== "object") throw $ERR_INVALID_ARG_TYPE(name, "object", value);
+  if (typeof value !== "object" || value === null) throw $ERR_INVALID_ARG_TYPE(name, "object", value);
 }
 hideFromStack(validateObject);
 

src/js/node/events.ts

@@ -23,6 +23,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+const { ERR_INVALID_ARG_TYPE } = require("internal/errors");
 const { throwNotImplemented } = require("internal/shared");
 const {
   validateObject,
@@ -45,6 +46,7 @@ const captureRejectionSymbol = SymbolFor("nodejs.rejection");
 const ArrayPrototypeSlice = Array.prototype.slice;
 
 let FixedQueue;
+const kEmptyObject = Object.freeze({ __proto__: null });
 
 var defaultMaxListeners = 10;
 
@@ -348,7 +350,8 @@ EventEmitterPrototype.eventNames = function eventNames() {
 
 EventEmitterPrototype[kCapture] = false;
 
-function once(emitter, type, options) {
+function once(emitter, type, options = kEmptyObject) {
+  validateObject(options, "options");
   var signal = options?.signal;
   validateAbortSignal(signal, "options.signal");
   if (signal?.aborted) {
@@ -389,8 +392,6 @@ function once(emitter, type, options) {
   return promise;
 }
 
-const kEmptyObject = Object.freeze({ __proto__: null });
-
 const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
 function createIterResult(value, done) {
   return { value, done };
@@ -456,7 +457,7 @@ function on(emitter, event, options = kEmptyObject) {
 
       throw(err) {
         if (!err || !(err instanceof Error)) {
-          throw new ERR_INVALID_ARG_TYPE("EventEmitter.AsyncIterator", "Error", err);
+          throw ERR_INVALID_ARG_TYPE("EventEmitter.AsyncIterator", "Error", err);
         }
         errorHandler(err);
       },
@@ -605,20 +606,27 @@ function listenerCount(emitter, type) {
   return jsEventTargetGetEventListenersCount(emitter, type);
 }
 
-function eventTargetAgnosticRemoveListener(emitter, name, listener, flags?) {
+function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
   if (typeof emitter.removeListener === "function") {
     emitter.removeListener(name, listener);
-  } else {
+  } else if (typeof emitter.removeEventListener === "function") {
     emitter.removeEventListener(name, listener, flags);
+  } else {
+    throw ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
   }
 }
 
 function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   if (typeof emitter.on === "function") {
-    if (flags?.once) emitter.once(name, listener);
-    else emitter.on(name, listener);
-  } else {
+    if (flags?.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === "function") {
     emitter.addEventListener(name, listener, flags);
+  } else {
+    throw ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
   }
 }
 
@@ -633,12 +641,6 @@ class AbortError extends Error {
   }
 }
 
-function ERR_INVALID_ARG_TYPE(name, type, value) {
-  const err = new TypeError(`The "${name}" argument must be of type ${type}. Received ${value}`);
-  err.code = "ERR_INVALID_ARG_TYPE";
-  return err;
-}
-
 function ERR_OUT_OF_RANGE(name, range, value) {
   const err = new RangeError(`The "${name}" argument is out of range. It must be ${range}. Received ${value}`);
   err.code = "ERR_OUT_OF_RANGE";

test/js/node/test/parallel/events-on-async-iterator.test.js

@@ -30,7 +30,7 @@ test("basic", async () => {
   expect(ee.listenerCount("error")).toBe(0);
 });
 
-test.skip("invalidArgType", async () => {
+test("invalidArgType", async () => {
   assert.throws(
     () => on({}, "foo"),
     common.expectsError({
@@ -187,7 +187,7 @@ test("nextError", async () => {
   expect(ee.listeners("error").length).toBe(0);
 });
 
-test.skip("iterableThrow", async () => {
+test("iterableThrow", async () => {
   const ee = new EventEmitter();
   const iterable = on(ee, "foo");
 
@@ -206,7 +206,7 @@ test.skip("iterableThrow", async () => {
       iterable.throw();
     },
     {
-      message: 'The "EventEmitter.AsyncIterator" property must be' + " an instance of Error. Received undefined",
+      message: 'The "EventEmitter.AsyncIterator" argument must be' + " of type Error. Received: undefined",
       name: "TypeError",
     },
   );

test/js/node/test/parallel/events-once.test.js

@@ -16,14 +16,12 @@ test("onceAnEvent", async () => {
   strictEqual(ee.listenerCount("myevent"), 0);
 });
 
-test.skip("onceAnEventWithInvalidOptions", async () => {
+test("onceAnEventWithInvalidOptions", async () => {
   const ee = new EventEmitter();
 
   await Promise.all(
     [1, "hi", null, false, () => {}, Symbol(), 1n].map(options => {
-      return rejects(once(ee, "myevent", options), {
-        code: "ERR_INVALID_ARG_TYPE",
-      });
+      expect.toThrowWithCode(() => once(ee, "myevent", options), "ERR_INVALID_ARG_TYPE");
     }),
   );
 });
@@ -142,11 +140,9 @@ test("onceWithEventTargetError", async () => {
   strictEqual(err, error);
 });
 
-test.skip("onceWithInvalidEventEmmiter", async () => {
+test("onceWithInvalidEventEmmiter", async () => {
   const ac = new AbortController();
-  return rejects(once(ac, "myevent"), {
-    code: "ERR_INVALID_ARG_TYPE",
-  });
+  expect.toThrowWithCode(() => once(ac, "myevent"), "ERR_INVALID_ARG_TYPE");
 });
 
 test("prioritizesEventEmitter", async () => {
@@ -157,22 +153,18 @@ test("prioritizesEventEmitter", async () => {
   await once(ee, "foo");
 });
 
-test.skip("abortSignalBefore", async () => {
+test("abortSignalBefore", async () => {
   const ee = new EventEmitter();
   ee.on("error", () => expect(false).toEqual(true));
   const abortedSignal = AbortSignal.abort();
 
   await Promise.all(
     [1, {}, "hi", null, false].map(signal => {
-      return rejects(once(ee, "foo", { signal }), {
-        code: "ERR_INVALID_ARG_TYPE",
-      });
+      expect.toThrowWithCode(() => once(ee, "foo", { signal }), "ERR_INVALID_ARG_TYPE");
     }),
   );
 
-  return rejects(once(ee, "foo", { signal: abortedSignal }), {
-    name: "AbortError",
-  });
+  expect(() => once(ee, "foo", { signal: abortedSignal })).toThrow();
 });
 
 test("abortSignalAfter", async () => {