chore: adopt node make_callback tests

Author: paradowstack

packages/node-addon-examples/src/index.ts

@@ -15,9 +15,7 @@ function assertLogs(cb: () => void, expectedMessages: string[]) {
     cb();
     if (expectedMessages.length > 0) {
       errors.push(
-        new Error(
-          `Missing expected message(s): ${expectedMessages.join(", ")}`,
-        ),
+        new Error(`Missing expected message(s): ${expectedMessages.join(", ")}`)
       );
     }
   } finally {
@@ -85,5 +83,6 @@ export const suites: Record<
       require("../tests/buffers/addon.js");
     },
     async: () => require("../tests/async/addon.js") as () => Promise<void>,
+    make_callback: () => require("../tests/make_callback/addon.js"),
   },
 };

packages/node-addon-examples/tests/make_callback/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.15)
+project(tests-make_callback)
+
+add_compile_definitions(NAPI_VERSION=8)
+
+add_library(addon SHARED addon.c ${CMAKE_JS_SRC})
+set_target_properties(addon PROPERTIES PREFIX "" SUFFIX ".node")
+target_include_directories(addon PRIVATE  ${CMAKE_JS_INC})
+target_link_libraries(addon PRIVATE ${CMAKE_JS_LIB})
+target_compile_features(addon PRIVATE cxx_std_17)
+
+if(MSVC AND CMAKE_JS_NODELIB_DEF AND CMAKE_JS_NODELIB_TARGET)
+  # Generate node.lib
+  execute_process(COMMAND ${CMAKE_AR} /def:${CMAKE_JS_NODELIB_DEF} /out:${CMAKE_JS_NODELIB_TARGET} ${CMAKE_STATIC_LINKER_FLAGS})
+endif()

packages/node-addon-examples/tests/make_callback/addon.c

@@ -0,0 +1,68 @@
+#include <assert.h>
+#include <node_api.h>
+#include <stdio.h>
+#include "../RuntimeNodeApiTestsCommon.h"
+
+#define MAX_ARGUMENTS 10
+#define RESERVED_ARGS 3
+
+static napi_value MakeCallback(napi_env env, napi_callback_info info) {
+  size_t argc = MAX_ARGUMENTS;
+  size_t n;
+  napi_value args[MAX_ARGUMENTS];
+  // NOLINTNEXTLINE (readability/null_usage)
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NODE_API_ASSERT(env, argc > 0, "Wrong number of arguments");
+  printf("Make callback called with %zu arguments\n", argc);
+
+  napi_value resource = args[0];
+  napi_value recv = args[1];
+  napi_value func = args[2];
+
+  napi_value argv[MAX_ARGUMENTS - RESERVED_ARGS];
+  for (n = RESERVED_ARGS; n < argc; n += 1) {
+    argv[n - RESERVED_ARGS] = args[n];
+  }
+
+  napi_valuetype func_type;
+
+  NODE_API_CALL(env, napi_typeof(env, func, &func_type));
+
+  napi_value resource_name;
+  NODE_API_CALL(env,
+      napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &resource_name));
+
+  napi_async_context context;
+  NODE_API_CALL(env, napi_async_init(env, resource, resource_name, &context));
+
+  napi_value result;
+  if (func_type == napi_function) {
+    NODE_API_CALL(env,
+        napi_make_callback(
+            env, context, recv, func, argc - RESERVED_ARGS, argv, &result));
+  } else {
+    NODE_API_ASSERT(env, false, "Unexpected argument type");
+  }
+
+  NODE_API_CALL(env, napi_async_destroy(env, context));
+
+  return result;
+}
+
+static napi_value Init(napi_env env, napi_value exports) {
+  napi_value fn;
+  NODE_API_CALL(env,
+      napi_create_function(
+          // NOLINTNEXTLINE (readability/null_usage)
+          env,
+          NULL,
+          NAPI_AUTO_LENGTH,
+          MakeCallback,
+          NULL,
+          &fn));
+  NODE_API_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

packages/node-addon-examples/tests/make_callback/addon.js

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable no-undef */
+const assert = require("assert");
+const binding = require("bindings")("addon.node");
+const makeCallback = binding.makeCallback;
+
+/**
+ * Resource should be able to be arbitrary objects without special internal
+ * slots. Testing with plain object here.
+ */
+
+function myMultiArgFunc(arg1, arg2, arg3) {
+  assert.strictEqual(arg1, 1);
+  assert.strictEqual(arg2, 2);
+  assert.strictEqual(arg3, 3);
+  return 42;
+}
+
+module.exports = () => {
+  const resource = {};
+  const process = (module.exports = {});
+
+  assert.strictEqual(
+    makeCallback(resource, process, function () {
+      assert.strictEqual(arguments.length, 0);
+      assert.strictEqual(this, process);
+      return 42;
+    }),
+    42
+  );
+
+  assert.strictEqual(
+    makeCallback(
+      resource,
+      process,
+      function (x) {
+        assert.strictEqual(arguments.length, 1);
+        assert.strictEqual(this, process);
+        assert.strictEqual(x, 1337);
+        return 42;
+      },
+      1337
+    ),
+    42
+  );
+
+  assert.strictEqual(
+    makeCallback(resource, process, myMultiArgFunc, 1, 2, 3),
+    42
+  );
+
+  // TODO(node-api): napi_make_callback needs to support
+  // strings passed for the func argument
+  //
+  // const recv = {
+  //   one: function () {
+  //     assert.strictEqual(0, arguments.length);
+  //     assert.strictEqual(this, recv);
+  //     return 42;
+  //   },
+  //   two: function (x) {
+  //     assert.strictEqual(1, arguments.length);
+  //     assert.strictEqual(this, recv);
+  //     assert.strictEqual(x, 1339);
+  //     return 42;
+  //   },
+  // };
+
+  // assert.strictEqual(makeCallback(recv, "one"), 42);
+  // assert.strictEqual(makeCallback(recv, "two", 1337), 42);
+  //
+  // Check that callbacks on a receiver from a different context works.
+  // const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
+  // const foreignObject = { fortytwo: () => 42 };
+  // assert.strictEqual(makeCallback(foreignObject, "fortytwo"), 42);
+
+  // Check that the callback is made in the context of the receiver.
+
+  // const target = vm.runInNewContext(`
+  //     (function($Object) {
+  //       if (Object === $Object)
+  //         throw new Error('bad');
+  //       return Object;
+  //     })
+  // `);
+  // assert.notStrictEqual(makeCallback(resource, process, target, Object), Object);
+
+  // // Runs in inner context.
+  // const forward = vm.runInNewContext(`
+  //     (function(forward) {
+  //       return forward(Object);
+  //     })
+  // `);
+
+  // // Runs in outer context.
+  // function endpoint($Object) {
+  //   if (Object === $Object)
+  //     throw new Error('bad');
+  //   return Object;
+  // }
+
+  // assert.strictEqual(makeCallback(resource, process, forward, endpoint), Object);
+};

packages/node-addon-examples/tests/make_callback/binding.gyp

@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "addon",
+      "sources": [ "addon.c" ]
+    }
+  ]
+}

packages/node-addon-examples/tests/make_callback/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "make-callback-test",
+  "version": "0.0.0",
+  "description": "Tests of runtime async functions",
+  "main": "addon.js",
+  "private": true,
+  "dependencies": {
+    "bindings": "~1.5.0"
+  },
+  "scripts": {
+    "test": "node addon.js"
+  },
+  "gypfile": true
+}