Add GTest utility methods to test C++ Turbo Module EventEmitters (#54060)

Summary:
Pull Request resolved: #54060

Changelog: [Internal]

Adds a test case to assert Turbo Module eventEmitter properties in GTests

Reviewed By: javache

Differential Revision: D83280050

fbshipit-source-id: 6c05d779c38a6988f07a11ccb436429aa1a12975

Author: christophpurrer

packages/react-native/ReactCommon/react/bridging/EventEmitter.h

@@ -28,14 +28,27 @@ class EventSubscription {
   EventSubscription(const EventSubscription&) = delete;
   EventSubscription& operator=(const EventSubscription&) = delete;
 
+  void remove() {
+    remove_();
+  }
+
  private:
   friend Bridging<EventSubscription>;
-
   std::function<void()> remove_;
 };
 
 template <>
 struct Bridging<EventSubscription> {
+  static EventSubscription fromJs(
+      jsi::Runtime& rt,
+      const jsi::Object& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    auto listener = bridging::fromJs<AsyncCallback<>>(
+        rt, value.getProperty(rt, "remove"), jsInvoker);
+    return EventSubscription(
+        [listener = std::move(listener)]() mutable { listener(); });
+  }
+
   static jsi::Object toJs(
       jsi::Runtime& rt,
       const EventSubscription& eventSubscription,

packages/react-native/ReactCommon/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -91,6 +91,8 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
         size_t count);
   };
   std::unordered_map<std::string, MethodMetadata> methodMap_;
+
+  friend class TurboModuleTestFixtureInternal;
   std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
       eventEmitterMap_;
 

packages/react-native/ReactCommon/react/nativemodule/core/tests/TurboModuleTestFixture.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <ReactCommon/TestCallInvoker.h>
+#include <ReactCommon/TurboModule.h>
 #include <gtest/gtest.h>
 #include <hermes/hermes.h>
 #include <react/bridging/Bridging.h>
@@ -16,10 +17,25 @@
 #include <optional>
 
 namespace facebook::react {
-class TurboModule;
+
+class TurboModuleTestFixtureInternal {
+ public:
+  static bool containsEventEmitter(
+      TurboModule& turboModule,
+      const std::string& eventEmitterName) {
+    return turboModule.eventEmitterMap_.contains(eventEmitterName);
+  }
+
+  static const std::shared_ptr<IAsyncEventEmitter> getEventEmitter(
+      TurboModule& turboModule,
+      const std::string& eventEmitterName) {
+    return turboModule.eventEmitterMap_.at(eventEmitterName);
+  }
+};
 
 template <typename T, typename... Args>
-class TurboModuleTestFixture : public ::testing::Test {
+class TurboModuleTestFixture : public TurboModuleTestFixtureInternal,
+                               public ::testing::Test {
   static_assert(
       std::is_base_of<TurboModule, T>::value,
       "T must be derived from TurboModule");
@@ -54,6 +70,29 @@ class TurboModuleTestFixture : public ::testing::Test {
             }));
   }
 
+  template <typename... EventType, typename Listener>
+  EventSubscription addEventEmitterListener(
+      jsi::Runtime& rt,
+      const std::string& eventEmitterName,
+      Listener&& listener) {
+    EXPECT_TRUE(containsEventEmitter(*module_, eventEmitterName));
+    auto listenJs = bridging::toJs(
+        rt,
+        [listener = std::forward<Listener>(listener)](
+            const EventType&... event) { listener(event...); },
+        jsInvoker_);
+    std::shared_ptr<AsyncEventEmitter<EventType...>> eventEmitter =
+        std::static_pointer_cast<AsyncEventEmitter<EventType...>>(
+            getEventEmitter(*module_, eventEmitterName));
+    jsi::Object eventEmitterJs = bridging::toJs(rt, *eventEmitter, jsInvoker_);
+    auto eventSubscriptionJs =
+        jsi::Object(eventEmitterJs.asFunction(rt)
+                        .callWithThis(rt, eventEmitterJs, listenJs)
+                        .asObject(rt));
+    return bridging::fromJs<EventSubscription>(
+        rt, eventSubscriptionJs, jsInvoker_);
+  }
+
   void TearDown() override {
     module_ = nullptr;
     jsInvoker_ = nullptr;

packages/rn-tester/NativeCxxModuleExample/tests/NativeCxxModuleExampleTests.cpp

@@ -8,7 +8,6 @@
 #include <NativeCxxModuleExample/NativeCxxModuleExample.h>
 #include <ReactCommon/TurboModuleTestFixture.h>
 #include <gtest/gtest.h>
-#include <list>
 #include <memory>
 #include <optional>
 #include <vector>
@@ -172,4 +171,25 @@ TEST_F(
   EXPECT_EQ(module_->getWithWithOptionalArgs(*runtime_, false), false);
 }
 
+TEST_F(NativeCxxModuleExampleTests, VoidFunEmitsEvents) {
+  int onPressCalled = 0;
+  std::string onClickCalled;
+  auto onPressSubscription = addEventEmitterListener<>(
+      *runtime_, "onPress", [&]() { onPressCalled++; });
+  addEventEmitterListener<std::string>(
+      *runtime_, "onClick", [&](const std::string& event) {
+        onClickCalled = event;
+      });
+  module_->voidFunc(*runtime_);
+  jsInvoker_->flushQueue();
+  EXPECT_EQ(onPressCalled, 1);
+  EXPECT_EQ(onClickCalled, "value from callback on click!");
+
+  onPressSubscription.remove();
+  jsInvoker_->flushQueue();
+
+  module_->voidFunc(*runtime_);
+  jsInvoker_->flushQueue();
+  EXPECT_EQ(onPressCalled, 1);
+}
 } // namespace facebook::react