feat: add unit test infrastructure with mock RocketMQ library

Introduce a comprehensive testing framework that enables unit testing
without requiring the actual RocketMQ C++ library. This includes:

- Mock RocketMQ headers and stub implementation for isolated testing
- CMake options for coverage and stub library configuration
- Jest test suites for Producer, PushConsumer, ConsumerAck, and init
- Test helper for conditional native binding loading
- Coverage file patterns added to .gitignore
- AddonData class for thread-safe instance data management

Author: noodanee

.gitignore

@@ -208,3 +208,11 @@ deps/rocketmq/test/bin
 deps/rocketmq/tmp_*
 deps/rocketmq/libs/signature/lib
 -
+
+### Coverage ###
+coverage.html
+coverage.css
+coverage.*.html
+*.gcda
+*.gcno
+*.gcov

CMakeLists.txt

@@ -7,6 +7,8 @@ add_definitions(-DNODE_RUNTIME=node)
 add_definitions(-DBUILDING_NODE_EXTENSION)
 
 option(ROCKETMQ_FORCE_STATIC_MUSL "Link against a provided static musl libc archive" OFF)
+option(ROCKETMQ_ENABLE_COVERAGE "Enable coverage flags" OFF)
+option(ROCKETMQ_USE_STUB "Use RocketMQ stub library for tests" OFF)
 
 set(NPX_CMD npx)
 
@@ -19,7 +21,20 @@ execute_process(
 message(STATUS "CMake.js configurations: INC=${CMAKE_JS_INC}")
 
 include_directories(${CMAKE_JS_INC})
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/deps/rocketmq/include)
+
+if(ROCKETMQ_USE_STUB)
+    add_definitions(-DROCKETMQ_USE_STUB=1)
+    set(ROCKETMQ_STUB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/test/mocks/rocketmq")
+    file(GLOB ROCKETMQ_STUB_SOURCES "${ROCKETMQ_STUB_ROOT}/src/*.cpp")
+    add_library(rocketmq_stub STATIC ${ROCKETMQ_STUB_SOURCES})
+    set_target_properties(rocketmq_stub PROPERTIES POSITION_INDEPENDENT_CODE ON)
+    target_include_directories(rocketmq_stub PUBLIC "${ROCKETMQ_STUB_ROOT}/include")
+    include_directories("${ROCKETMQ_STUB_ROOT}/include")
+    set(ROCKETMQ_LIB rocketmq_stub)
+else()
+    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/deps/rocketmq/include)
+    set(ROCKETMQ_LIB ${CMAKE_CURRENT_SOURCE_DIR}/deps/rocketmq/bin/librocketmq.a)
+endif()
 
 file(GLOB SOURCE_FILES "src/*.cpp")
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
@@ -29,7 +44,7 @@ set_target_properties(${PROJECT_NAME}
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/build"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/build"
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/build")
-target_link_libraries(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/deps/rocketmq/bin/librocketmq.a)
+target_link_libraries(${PROJECT_NAME} ${ROCKETMQ_LIB})
 
 set(CMAKE_DEPENDS_USE_COMPILER FALSE)
 set(CMAKE_SKIP_DEPENDENCY_TRACKING TRUE)
@@ -52,3 +67,9 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 else()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11 -stdlib=libc++")
 endif()
+
+if(ROCKETMQ_ENABLE_COVERAGE)
+    add_definitions(-DROCKETMQ_COVERAGE=1)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fprofile-arcs -ftest-coverage")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
+endif()

lib/push_consumer.js

@@ -46,7 +46,24 @@ class RocketMQPushConsumer extends EventEmitter {
             options.logLevel = OPTIONS_LOG_LEVEL[options.logLevel.toUpperCase()] || OPTIONS_LOG_LEVEL.INFO;
         }
         this.core = new binding.PushConsumer(groupId, instanceName, options);
-        this.core.setListener(this.emit.bind(this, "message"));
+        this.core.setListener((msg, ack) => {
+            try {
+                this.emit("message", msg, ack);
+            } catch (err) {
+                try {
+                    if (ack && typeof ack.done === "function") {
+                        ack.done(false);
+                    }
+                } catch (_) {
+                }
+                if (this.listenerCount("error") > 0) {
+                    try {
+                        this.emit("error", err, msg, ack);
+                    } catch (_) {
+                    }
+                }
+            }
+        });
         this.status = START_STATUS.STOPPED;
     }
 

package.json

@@ -24,6 +24,12 @@
       10
     ]
   },
+  "scripts": {
+    "build": "cmake-js build",
+    "build:coverage": "cmake-js rebuild --CDROCKETMQ_ENABLE_COVERAGE=ON --CDROCKETMQ_USE_STUB=ON",
+    "test": "node --expose-gc --test --test-force-exit",
+    "test:coverage": "npm run build:coverage && node --expose-gc --test --test-force-exit && gcovr -r . --filter src --exclude test --print-summary"
+  },
   "dependencies": {
     "bindings": "^1.5.0"
   },

src/addon_data.h

@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __ROCKETMQ_ADDON_DATA_H__
+#define __ROCKETMQ_ADDON_DATA_H__
+
+#include <napi.h>
+
+namespace __node_rocketmq__ {
+
+struct AddonData {
+  Napi::FunctionReference producer_constructor;
+  Napi::FunctionReference push_consumer_constructor;
+  Napi::FunctionReference consumer_ack_constructor;
+};
+
+AddonData* GetAddonData(Napi::Env env);
+
+}  // namespace __node_rocketmq__
+
+#endif

src/consumer_ack.cpp

@@ -15,31 +15,49 @@
  * limitations under the License.
  */
 #include "consumer_ack.h"
+
+#include <cstdlib>
 #include <exception>
-#include "napi.h"
+
+#include <napi.h>
+
+#include "addon_data.h"
 
 namespace __node_rocketmq__ {
 
-static void DeleteFunctionReference(Napi::Env, Napi::FunctionReference* data) {
-  delete data;
+#if defined(ROCKETMQ_COVERAGE) || defined(ROCKETMQ_USE_STUB)
+namespace {
+bool IsEnvEnabled(const char* name) {
+  const char* value = std::getenv(name);
+  if (value == nullptr) {
+    return false;
+  }
+  return value[0] != '\0' && value[0] != '0';
+}
 }
+#endif
 
-Napi::Object ConsumerAck::Init(Napi::Env env, Napi::Object exports) {
+Napi::Object ConsumerAck::Init(Napi::Env env, Napi::Object exports, AddonData* addon_data) {
   Napi::Function func = DefineClass(
       env, "ConsumerAck", {InstanceMethod<&ConsumerAck::Done>("done")});
 
-  // Store the constructor in env to avoid memory leak
-  Napi::FunctionReference* constructor = new Napi::FunctionReference();
-  *constructor = Napi::Persistent(func);
-  env.SetInstanceData<Napi::FunctionReference, DeleteFunctionReference>(constructor);
+  addon_data->consumer_ack_constructor = Napi::Persistent(func);
 
   exports.Set("ConsumerAck", func);
   return exports;
 }
 
 Napi::Object ConsumerAck::NewInstance(Napi::Env env) {
-  Napi::Object obj = env.GetInstanceData<Napi::FunctionReference>()->New({});
-  return obj;
+  AddonData* addon_data = GetAddonData(env);
+#if defined(ROCKETMQ_COVERAGE) || defined(ROCKETMQ_USE_STUB)
+  if (addon_data == nullptr || IsEnvEnabled("ROCKETMQ_STUB_CONSUMER_ACK_NULL_ADDON_DATA")) {
+#else
+  if (addon_data == nullptr) {
+#endif
+    Napi::Error::New(env, "ConsumerAck constructor not initialized").ThrowAsJavaScriptException();
+    return Napi::Object();
+  }
+  return addon_data->consumer_ack_constructor.New({});
 }
 
 ConsumerAck::ConsumerAck(const Napi::CallbackInfo& info)
@@ -49,34 +67,39 @@ void ConsumerAck::SetPromise(std::promise<bool>&& promise) {
   promise_ = std::move(promise);
 }
 
-void ConsumerAck::Done(bool ack) {
-  try {
-    promise_.set_value(ack);
-  } catch (const std::future_error& e) {
-    // ignore
-  }
-}
-
 void ConsumerAck::Done(std::exception_ptr exception) {
-  try {
-    promise_.set_exception(exception);
-  } catch (const std::future_error& e) {
-    // ignore
+  if (!done_called_.exchange(true)) {
+    try {
+      promise_.set_exception(exception);
+    } catch (const std::future_error&) {
+    }
   }
 }
 
 Napi::Value ConsumerAck::Done(const Napi::CallbackInfo& info) {
-  try {
-    if (info.Length() >= 1) {
-      Napi::Value ack = info[0];
-      if (ack.IsBoolean() && !ack.ToBoolean()) {
-        Done(false);
-        return info.Env().Undefined();
-      }
+  if (done_called_.exchange(true)) {
+    return info.Env().Undefined();
+  }
+
+  bool ack = true;
+  if (info.Length() >= 1) {
+    Napi::Value ack_value = info[0];
+    if (ack_value.IsBoolean() && !ack_value.ToBoolean()) {
+      ack = false;
     }
-    Done(true);
-  } catch (const std::exception& e) {
-    // ignore
+  }
+
+#if defined(ROCKETMQ_COVERAGE) || defined(ROCKETMQ_USE_STUB)
+  if (IsEnvEnabled("ROCKETMQ_STUB_CONSUMER_ACK_FORCE_FUTURE_ERROR")) {
+    try {
+      promise_.set_value(true);
+    } catch (const std::future_error&) {
+    }
+  }
+#endif
+  try {
+    promise_.set_value(ack);
+  } catch (const std::future_error&) {
   }
   return info.Env().Undefined();
 }

src/consumer_ack.h

@@ -17,29 +17,32 @@
 #ifndef __ROCKETMQ_CONSUMER_ACK_H__
 #define __ROCKETMQ_CONSUMER_ACK_H__
 
+#include <atomic>
 #include <future>
 
 #include <napi.h>
 
 namespace __node_rocketmq__ {
 
+struct AddonData;
+
 class ConsumerAck : public Napi::ObjectWrap<ConsumerAck> {
  public:
-  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Object Init(Napi::Env env, Napi::Object exports, AddonData* addon_data);
   static Napi::Object NewInstance(Napi::Env env);
 
   ConsumerAck(const Napi::CallbackInfo& info);
 
   void SetPromise(std::promise<bool>&& promise);
 
-  void Done(bool ack);
   void Done(std::exception_ptr exception);
 
  private:
   Napi::Value Done(const Napi::CallbackInfo& info);
 
  private:
   std::promise<bool> promise_;
+  std::atomic<bool> done_called_{false};
 };
 
 }  // namespace __node_rocketmq__