refactor callback tests

Author: typesafe

src/c.zig

@@ -3,50 +3,10 @@ pub const c = @cImport({
     @cInclude("node_api.h");
 });
 
-// pub const cc = wrapCLib(c);
-
-// fn wrapCLib(comptime T: type) type {
-//     const decls = @typeInfo(T).@"struct".decls;
-
-//     const N = decls.len;
-
-//     var fields: [N]std.builtin.Type.StructField = undefined;
-
-//     inline for (decls, 0..) |d, i| {
-//         const wrapper = opaque {
-//             pub fn f() NodeApiError!void {}
-//         }.f;
-//         const f : std.builtin.Type.Fn = .{
-//             .
-//         };
-//         fields[i] = .{
-//             .name = d.name,
-//             .type = d.ty,
-//             .default_value = null, // keep it simple; you can wire a default if you want
-//             .is_comptime = false,
-//             .alignment = @alignOf(d.ty),
-//         };
-//     }
-
-//     return @Type(.{
-//         .Struct = .{
-//             .layout = .Auto,
-//             .fields = &fields,
-//             .decls = &.{}, // no nested declarations (constants/functions) added here
-//             .is_tuple = false,
-//         },
-//     });
-// }
-
 /// Maps a node_api status codes to Zig errors.
 pub fn statusToError(status: c_uint) NodeApiError!void {
-    const v: NapiStatusValue = @enumFromInt(status);
-
-    if (v == NapiStatusValue.ok) {
-        return;
-    }
-
-    return switch (v) {
+    return switch (@as(NapiStatusValue, @enumFromInt(status))) {
+        NapiStatusValue.ok => return,
         NapiStatusValue.invalid_arg => NodeApiError.InvalidArg,
         NapiStatusValue.object_expected => NodeApiError.ObjectExpected,
         NapiStatusValue.string_expected => NodeApiError.StringExpected,
@@ -132,15 +92,12 @@ pub const NodeApiError = error{
 
 // https://nodejs.org/api/n-api.html#error-handling
 pub fn handleError(env: c.napi_env, err: anyerror) void {
-    std.log.debug("handling error for {any}", .{err});
+    std.log.debug("handling error '{any}'", .{err});
 
     var err_info: [*c]const c.napi_extended_error_info = undefined;
     if (c.napi_get_last_error_info(env, &err_info) != c.napi_ok) {
         @panic("failed to call `napi_get_last_error_info`.");
     }
-    // if (err_info != null) {
-    //     std.log.debug("err_infooo {s}", .{err_info.*.error_message});
-    // }
 
     // In many cases when a Node-API function is called and an exception is already pending, the function will return immediately with a napi_status of napi_pending_exception.
     // However, this is not the case for all functions. Node-API allows a subset of the functions to be called to allow for some minimal cleanup before returning to JavaScript.
@@ -154,8 +111,6 @@ pub fn handleError(env: c.napi_env, err: anyerror) void {
         pending_exception = true;
     }
 
-    std.log.debug("pending_expeption {any}", .{pending_exception});
-
     if (pending_exception) {
         // the pending exception will be thrown in JS
         return;

tests/callbacks.spec.ts

@@ -1,27 +1,26 @@
 import addon from "node-api-test-module";
 import { describe, it, expect } from "bun:test";
 
-describe("defineFunction with callback", () => {
-  it("should call callback", () => {
+describe("callback parameters", () => {
+  const capturedValue = 3;
+
+  it("support closures as expected", () => {
     expect(
-      addon.functions.fnCallback((foo) => {
-        console.log("CALLED FROM ZIG", foo);
-        return foo * 3;
+      addon.functions.fnCallback(123, (foo: number) => {
+        return foo * capturedValue;
       })
-    ).toEqual("ok");
+    ).toEqual(369);
   });
 
-  it("should propagate errors thrown in callback", () => {
+  it("should propagate thrown errors", () => {
     expect(() => {
-      addon.functions.fnCallback(() => {
+      addon.functions.fnCallback(123, () => {
         throw new Error("Kablooie");
       });
     }).toThrowError("Kablooie");
   });
-});
 
-describe("defineAsyncFunction with callback", () => {
-  it("should call callback", async () => {
+  it.skip("TODO: should be callable from async functions", async () => {
     expect(
       await addon.functions.fnCallbackAsync((foo) => {
         console.log("CALLED FROM ZIG", foo);

tests/functions.spec.ts

@@ -1,18 +1,18 @@
 import addon from "node-api-test-module";
 import { describe, it, expect } from "bun:test";
 
-describe("defineFunction", () => {
-  it("should define function", () => {
+describe("functions", () => {
+  it("should be defined as function", () => {
     expect(addon.functions.fnWithSerializedParams).toBeFunction();
   });
 
-  it("should fail when called with missing arguments", () => {
+  it("should throw MissingArguments when called with missing arguments", () => {
     expect(() => addon.functions.fnWithSerializedParams(123)).toThrow(
       "MissingArguments"
     );
   });
 
-  it("should fail when called with argument of different type", () => {
+  it("should throw when called with argument of different type", () => {
     expect(() => addon.functions.fnWithSerializedParams(123, "foo")).toThrow(
       "BooleanExpected"
     );
@@ -22,6 +22,7 @@ describe("defineFunction", () => {
     it("should unwrap the instance", () => {
       const i = new addon.TestClass(123);
       expect(addon.functions.fnWithJsNewedNativeInstance(i)).toBe(i);
+      expect(i.foo).toEqual(124);
     });
   });
 
@@ -33,19 +34,6 @@ describe("defineFunction", () => {
     });
   });
 
-  describe("with callback parameter", () => {
-    const capturedValue = 3;
-    it("should call callback", () => {
-      expect(
-        addon.functions.fnCallback(123, (foo) => {
-          console.log(this);
-          console.log("CALLED FROM ZIG", foo);
-          return foo * capturedValue;
-        })
-      ).toEqual(369);
-    });
-  });
-
   describe("calling with too few arguments", () => {
     it("should serialize params and return values", () => {
       expect(addon.functions.fnWithAllocatorParam(42)).toEqual(

tests/node_modules/node-api-test-module/zig-module.node

@@ -90,6 +90,7 @@ fn fnWithAllocatorParam(allocator: std.mem.Allocator, len: u32) ![]u8 {
 }
 
 fn fnWithJsNewedNativeInstance(newed_in_js: *TestClass) !*TestClass {
+    newed_in_js.foo += 1;
     std.log.info("newed_in_js {any}", .{newed_in_js});
     return newed_in_js;
 }