react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/jsinspector-modern/tests/InspectorPackagerConnectionTest.cpp

@@ -6,21 +6,12 @@
  */
 
 #include <fmt/format.h>
-#include <folly/dynamic.h>
-#include <folly/executors/ManualExecutor.h>
-#include <folly/executors/QueuedImmediateExecutor.h>
 #include <folly/json.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include <jsinspector-modern/InspectorInterfaces.h>
-#include <jsinspector-modern/InspectorPackagerConnection.h>
-
-#include <memory>
-
 #include "FollyDynamicMatchers.h"
-#include "InspectorMocks.h"
-#include "UniquePtrFactory.h"
+#include "InspectorPackagerConnectionTest.h"
 
 using namespace ::testing;
 using namespace std::literals::chrono_literals;
@@ -29,115 +20,6 @@ using folly::dynamic, folly::toJson;
 
 namespace facebook::react::jsinspector_modern {
 
-namespace {
-
-template <typename Executor>
-class InspectorPackagerConnectionTestBase : public testing::Test {
- protected:
-  InspectorPackagerConnectionTestBase()
-      : packagerConnection_(
-            InspectorPackagerConnection{
-                "ws://mock-host:12345",
-                "my-device",
-                "my-app",
-                packagerConnectionDelegates_.make_unique(asyncExecutor_)}) {
-    auto makeSocket = webSockets_.lazily_make_unique<
-        const std::string&,
-        std::weak_ptr<IWebSocketDelegate>>();
-    ON_CALL(*packagerConnectionDelegate(), connectWebSocket(_, _))
-        .WillByDefault([makeSocket](auto&&... args) {
-          auto socket = makeSocket(std::forward<decltype(args)>(args)...);
-          socket->getDelegate().didOpen();
-          return std::move(socket);
-        });
-    EXPECT_CALL(*packagerConnectionDelegate(), connectWebSocket(_, _))
-        .Times(AnyNumber());
-  }
-
-  void TearDown() override {
-    // Forcibly clean up all pages currently registered with the inspector in
-    // order to isolate state between tests. NOTE: Using TearDown instead of a
-    // destructor so that we can use FAIL() etc.
-    std::vector<int> pagesToRemove;
-    auto pages = getInspectorInstance().getPages();
-    int liveConnectionCount = 0;
-    for (size_t i = 0; i != localConnections_.objectsVended(); ++i) {
-      if (localConnections_[i] != nullptr) {
-        liveConnectionCount++;
-        // localConnections_[i] is a strict mock and will complain when we
-        // removePage if the call is unexpected.
-        EXPECT_CALL(*localConnections_[i], disconnect());
-      }
-    }
-    for (auto& page : pages) {
-      getInspectorInstance().removePage(page.id);
-    }
-    if (!pages.empty() && (liveConnectionCount != 0)) {
-      if (!::testing::Test::HasFailure()) {
-        FAIL()
-            << "Test case ended with " << liveConnectionCount
-            << " open connection(s) and " << pages.size()
-            << " registered page(s). You must manually call removePage for each page.";
-      }
-    }
-    ::testing::Test::TearDown();
-  }
-
-  MockInspectorPackagerConnectionDelegate* packagerConnectionDelegate() {
-    // We only create one PackagerConnectionDelegate per test.
-    EXPECT_EQ(packagerConnectionDelegates_.objectsVended(), 1);
-    return packagerConnectionDelegates_[0];
-  }
-
-  Executor asyncExecutor_;
-
-  UniquePtrFactory<MockInspectorPackagerConnectionDelegate>
-      packagerConnectionDelegates_;
-  /**
-   * webSockets_ will hold the WebSocket instance(s) owned by
-   * packagerConnection_ while also allowing us to access them during
-   * the test. We can send messages *to* packagerConnection_ by
-   * calling webSockets_[i]->getDelegate().didReceiveMessage(...). Messages
-   * *from* packagerConnection_ will be found as calls to
-   * webSockets_[i]->send, which is a mock method installed by gmock.
-   * These are strict mocks, so method calls will fail if they are not
-   * expected with a corresponding call to EXPECT_CALL(...) - for example
-   * if unexpected WebSocket messages are sent.
-   */
-  UniquePtrFactory<StrictMock<MockWebSocket>> webSockets_;
-  /**
-   * localConnections_ will hold the LocalConnection instances owned
-   * by packagerConnection_ while also allowing us to access them
-   * during the test.
-   * These are strict mocks, so method calls will fail if they are not
-   * expected with a corresponding call to EXPECT_CALL(...).
-   */
-  UniquePtrFactory<StrictMock<MockLocalConnection>> localConnections_;
-  std::optional<InspectorPackagerConnection> packagerConnection_;
-};
-
-using InspectorPackagerConnectionTest =
-    InspectorPackagerConnectionTestBase<folly::QueuedImmediateExecutor>;
-
-/**
- * Fixture class for tests that run on a ManualExecutor. Work scheduled
- * on the executor is *not* run automatically; it must be manually advanced
- * in the body of the test.
- */
-class InspectorPackagerConnectionTestAsync
-    : public InspectorPackagerConnectionTestBase<folly::ManualExecutor> {
- public:
-  virtual void TearDown() override {
-    // Assert there are no pending tasks on the ManualExecutor.
-    auto tasksCleared = asyncExecutor_.clear();
-    EXPECT_EQ(tasksCleared, 0)
-        << "There were still pending tasks on asyncExecutor_ at the end of the test. Use advance() or run() as needed.";
-    InspectorPackagerConnectionTestBase<folly::ManualExecutor>::TearDown();
-  }
-};
-
-} // namespace
-
 TEST_F(InspectorPackagerConnectionTest, TestConnectThenDestroy) {
   packagerConnection_->connect();
 
@@ -237,8 +119,10 @@ TEST_F(InspectorPackagerConnectionTest, TestGetPages) {
                        AtJsonPtr("/app", Eq("my-app")),
                        AtJsonPtr("/capabilities/nativePageReloads", Eq(true)),
                        AtJsonPtr(
-                           "/capabilities/nativeSourceCodeFetching",
-                           Eq(false))),
+                           "/capabilities/nativeSourceCodeFetching", Eq(false)),
+                       AtJsonPtr(
+                           "/capabilities/supportsMultipleDebuggers",
+                           Eq(true))),
                    AllOf(
                        AtJsonPtr("/id", Eq(std::to_string(pageId2))),
                        AtJsonPtr("/title", Eq("my-app (my-device)")),
@@ -248,8 +132,10 @@ TEST_F(InspectorPackagerConnectionTest, TestGetPages) {
                        AtJsonPtr("/app", Eq("my-app")),
                        AtJsonPtr("/capabilities/nativePageReloads", Eq(true)),
                        AtJsonPtr(
-                           "/capabilities/nativeSourceCodeFetching",
-                           Eq(false)))}))))))
+                           "/capabilities/nativeSourceCodeFetching", Eq(false)),
+                       AtJsonPtr(
+                           "/capabilities/supportsMultipleDebuggers",
+                           Eq(true)))}))))))
       .RetiresOnSaturation();
   webSockets_[0]->getDelegate().didReceiveMessage(R"({
       "event": "getPages"
@@ -662,6 +548,7 @@ TEST_F(
         }})",
           toJson(std::to_string(pageId))));
   EXPECT_FALSE(localConnections_[0]);
+  EXPECT_EQ(localConnections_.objectsVended(), 1);
 }
 
 TEST_F(InspectorPackagerConnectionTest, TestMultipleDisconnect) {

package/ReactCommon/jsinspector-modern/tests/InspectorPackagerConnectionTest.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fmt/format.h>
+#include <folly/dynamic.h>
+#include <folly/executors/ManualExecutor.h>
+#include <folly/executors/QueuedImmediateExecutor.h>
+#include <folly/json.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <jsinspector-modern/InspectorInterfaces.h>
+#include <jsinspector-modern/InspectorPackagerConnection.h>
+
+#include <memory>
+
+#include "InspectorMocks.h"
+#include "UniquePtrFactory.h"
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Base test fixture for InspectorPackagerConnection tests.
+ *
+ * The Executor template parameter controls how asynchronous work is executed:
+ * - folly::QueuedImmediateExecutor: Work is executed immediately inline.
+ * - folly::ManualExecutor: Work must be manually advanced in the test.
+ */
+template <typename Executor>
+class InspectorPackagerConnectionTestBase : public testing::Test {
+ protected:
+  InspectorPackagerConnectionTestBase()
+      : packagerConnection_(
+            InspectorPackagerConnection{
+                "ws://mock-host:12345",
+                "my-device",
+                "my-app",
+                packagerConnectionDelegates_.make_unique(asyncExecutor_)})
+  {
+    auto makeSocket = webSockets_.lazily_make_unique<const std::string &, std::weak_ptr<IWebSocketDelegate>>();
+    ON_CALL(*packagerConnectionDelegate(), connectWebSocket(testing::_, testing::_))
+        .WillByDefault([makeSocket](auto &&...args) {
+          auto socket = makeSocket(std::forward<decltype(args)>(args)...);
+          socket->getDelegate().didOpen();
+          return std::move(socket);
+        });
+    EXPECT_CALL(*packagerConnectionDelegate(), connectWebSocket(testing::_, testing::_)).Times(testing::AnyNumber());
+  }
+
+  void TearDown() override
+  {
+    // Forcibly clean up all pages currently registered with the inspector in
+    // order to isolate state between tests. NOTE: Using TearDown instead of a
+    // destructor so that we can use FAIL() etc.
+    std::vector<int> pagesToRemove;
+    auto pages = getInspectorInstance().getPages();
+    int liveConnectionCount = 0;
+    for (size_t i = 0; i != localConnections_.objectsVended(); ++i) {
+      if (localConnections_[i] != nullptr) {
+        liveConnectionCount++;
+        // localConnections_[i] is a strict mock and will complain when we
+        // removePage if the call is unexpected.
+        EXPECT_CALL(*localConnections_[i], disconnect());
+      }
+    }
+    for (auto &page : pages) {
+      getInspectorInstance().removePage(page.id);
+    }
+    if (!pages.empty() && (liveConnectionCount != 0)) {
+      if (!::testing::Test::HasFailure()) {
+        FAIL() << "Test case ended with " << liveConnectionCount << " open connection(s) and " << pages.size()
+               << " registered page(s). You must manually call removePage for each page.";
+      }
+    }
+    ::testing::Test::TearDown();
+  }
+
+  MockInspectorPackagerConnectionDelegate *packagerConnectionDelegate()
+  {
+    // We only create one PackagerConnectionDelegate per test.
+    EXPECT_EQ(packagerConnectionDelegates_.objectsVended(), 1);
+    return packagerConnectionDelegates_[0];
+  }
+
+  Executor asyncExecutor_;
+
+  UniquePtrFactory<MockInspectorPackagerConnectionDelegate> packagerConnectionDelegates_;
+  /**
+   * webSockets_ will hold the WebSocket instance(s) owned by
+   * packagerConnection_ while also allowing us to access them during
+   * the test. We can send messages *to* packagerConnection_ by
+   * calling webSockets_[i]->getDelegate().didReceiveMessage(...). Messages
+   * *from* packagerConnection_ will be found as calls to
+   * webSockets_[i]->send, which is a mock method installed by gmock.
+   * These are strict mocks, so method calls will fail if they are not
+   * expected with a corresponding call to EXPECT_CALL(...) - for example
+   * if unexpected WebSocket messages are sent.
+   */
+  UniquePtrFactory<testing::StrictMock<MockWebSocket>> webSockets_;
+  /**
+   * localConnections_ will hold the LocalConnection instances owned
+   * by packagerConnection_ while also allowing us to access them
+   * during the test.
+   * These are strict mocks, so method calls will fail if they are not
+   * expected with a corresponding call to EXPECT_CALL(...).
+   */
+  UniquePtrFactory<testing::StrictMock<MockLocalConnection>> localConnections_;
+  std::optional<InspectorPackagerConnection> packagerConnection_;
+};
+
+/**
+ * Standard test fixture that uses QueuedImmediateExecutor.
+ * Work scheduled on the executor is run immediately inline.
+ */
+using InspectorPackagerConnectionTest = InspectorPackagerConnectionTestBase<folly::QueuedImmediateExecutor>;
+
+/**
+ * Test fixture that uses ManualExecutor.
+ * Work scheduled on the executor is *not* run automatically; it must be
+ * manually advanced in the body of the test.
+ */
+class InspectorPackagerConnectionTestAsync : public InspectorPackagerConnectionTestBase<folly::ManualExecutor> {
+ public:
+  void TearDown() override
+  {
+    // Assert there are no pending tasks on the ManualExecutor.
+    auto tasksCleared = asyncExecutor_.clear();
+    EXPECT_EQ(tasksCleared, 0)
+        << "There were still pending tasks on asyncExecutor_ at the end of the test. Use advance() or run() as needed.";
+    InspectorPackagerConnectionTestBase<folly::ManualExecutor>::TearDown();
+  }
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/JsiIntegrationTest.cpp

@@ -567,11 +567,12 @@ TYPED_TEST(JsiIntegrationHermesTest, EvaluateExpressionInExecutionContext) {
           std::to_string(executionContextId)));
 }
 
-#if !defined(HERMES_STATIC_HERMES)
-// FIXME(T239924718): Breakpoint resolution in Static Hermes is broken for
-// locations without column numbers under lazy compilation.
+#if !defined(HERMES_STATIC_HERMES_STABLE)
+// TODO: Unconditionally enable test for line-only (columnless) breakpoints
+// after D83595036 (fix for T239924718) ships to the stable branch of Static
+// Hermes.
 
-TYPED_TEST(JsiIntegrationHermesTest, ResolveBreakpointAfterEval) {
+TYPED_TEST(JsiIntegrationHermesTest, ResolveColumnlessBreakpointAfterEval) {
   this->connect();
 
   InSequence s;
@@ -609,7 +610,7 @@ TYPED_TEST(JsiIntegrationHermesTest, ResolveBreakpointAfterEval) {
                                })");
 }
 
-TYPED_TEST(JsiIntegrationHermesTest, ResolveBreakpointAfterReload) {
+TYPED_TEST(JsiIntegrationHermesTest, ResolveColumnlessBreakpointAfterReload) {
   this->connect();
 
   InSequence s;
@@ -651,7 +652,158 @@ TYPED_TEST(JsiIntegrationHermesTest, ResolveBreakpointAfterReload) {
       scriptInfo->value()["params"]["scriptId"]);
 }
 
-#endif // !defined(HERMES_STATIC_HERMES)
+#endif // !defined(HERMES_STATIC_HERMES_STABLE)
+
+TYPED_TEST(JsiIntegrationHermesTest, ResolveColumnBreakpointAfterEval) {
+  this->connect();
+
+  InSequence s;
+
+  this->expectMessageFromPage(JsonEq(R"({
+                                         "id": 1,
+                                         "result": {}
+                                       })"));
+  this->toPage_->sendMessage(R"({
+                                 "id": 1,
+                                 "method": "Debugger.enable"
+                               })");
+
+  auto scriptInfo = this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Debugger.scriptParsed"),
+      AtJsonPtr("/params/url", "breakpointTest.js"))));
+  this->eval(R"( // line 0
+    globalThis.foo = function() { // line 1
+      Date.now(); // line 2
+    };
+    //# sourceURL=breakpointTest.js
+  )");
+  ASSERT_TRUE(scriptInfo->has_value());
+
+  this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/id", 2),
+      AtJsonPtr("/result/locations/0/lineNumber", 2),
+      AtJsonPtr("/result/locations/0/columnNumber", 6),
+      AtJsonPtr(
+          "/result/locations/0/scriptId",
+          scriptInfo->value()["params"]["scriptId"]))));
+  this->toPage_->sendMessage(R"({
+                                 "id": 2,
+                                 "method": "Debugger.setBreakpointByUrl",
+                                 "params": {"lineNumber": 2,
+                                             "columnNumber": 6,
+                                 "url": "breakpointTest.js"}
+                               })");
+}
+
+TYPED_TEST(JsiIntegrationHermesTest, ResolveColumnBreakpointAfterReload) {
+  this->connect();
+
+  InSequence s;
+
+  this->expectMessageFromPage(JsonEq(R"({
+                                         "id": 1,
+                                         "result": {}
+                                       })"));
+  this->toPage_->sendMessage(R"({
+                                 "id": 1,
+                                 "method": "Debugger.enable"
+                               })");
+
+  this->expectMessageFromPage(JsonParsed(AtJsonPtr("/id", 2)));
+  this->toPage_->sendMessage(R"({
+                                 "id": 2,
+                                 "method": "Debugger.setBreakpointByUrl",
+                                 "params": {"lineNumber": 2, "columnNumber": 6, "url": "breakpointTest.js"}
+                               })");
+
+  this->reload();
+
+  auto scriptInfo = this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Debugger.scriptParsed"),
+      AtJsonPtr("/params/url", "breakpointTest.js"))));
+  auto breakpointInfo = this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Debugger.breakpointResolved"),
+      AtJsonPtr("/params/location/lineNumber", 2),
+      AtJsonPtr("/params/location/columnNumber", 6))));
+  this->eval(R"( // line 0
+    globalThis.foo = function() { // line 1
+      Date.now(); // line 2
+    };
+    //# sourceURL=breakpointTest.js
+  )");
+  ASSERT_TRUE(breakpointInfo->has_value());
+  ASSERT_TRUE(scriptInfo->has_value());
+  EXPECT_EQ(
+      breakpointInfo->value()["params"]["location"]["scriptId"],
+      scriptInfo->value()["params"]["scriptId"]);
+}
+
+TYPED_TEST(JsiIntegrationHermesTest, TwoConnectionsEnableDebugger) {
+  this->connect();
+  auto secondary = this->connectSecondary();
+
+  EXPECT_CALL(
+      this->fromPage(), onMessage(JsonEq(R"({"id": 1, "result": {}})")));
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 2, "result": {}})")));
+
+  this->toPage_->sendMessage(R"({"id": 1, "method": "Debugger.enable"})");
+  secondary.toPage().sendMessage(R"({"id": 2, "method": "Debugger.enable"})");
+}
+
+TYPED_TEST(JsiIntegrationHermesTest, TwoConnectionsDebuggerLifecycle) {
+  this->connect();
+  auto secondary = this->connectSecondary();
+
+  this->expectMessageFromPage(JsonEq(R"({"id": 1, "result": {}})"));
+  this->toPage_->sendMessage(R"({"id": 1, "method": "Debugger.enable"})");
+
+  // Connections: Main (Debugger enabled), Secondary (Debugger disabled)
+  // --> Only the main connection receives Debugger events.
+  this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Debugger.scriptParsed"),
+      AtJsonPtr("/params/url", "script1.js"))));
+  this->eval("1 + 1; //# sourceURL=script1.js");
+
+  // Connections: Main (Debugger enabled), Secondary (Debugger being enabled)
+  // --> The secondary connection receives buffered Debugger events.
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 2, "result": {}})")));
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AllOf(
+          AtJsonPtr("/method", "Debugger.scriptParsed"),
+          AtJsonPtr("/params/url", "script1.js")))));
+  secondary.toPage().sendMessage(R"({"id": 2, "method": "Debugger.enable"})");
+
+  // Connections: Main (Debugger enabled), Secondary (Debugger enabled)
+  // --> Both connections receive Debugger events.
+  this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Debugger.scriptParsed"),
+      AtJsonPtr("/params/url", "script2.js"))));
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AllOf(
+          AtJsonPtr("/method", "Debugger.scriptParsed"),
+          AtJsonPtr("/params/url", "script2.js")))));
+  this->eval("2 + 2; //# sourceURL=script2.js");
+
+  this->expectMessageFromPage(JsonEq(R"({"id": 3, "result": {}})"));
+  this->toPage_->sendMessage(R"({"id": 3, "method": "Debugger.disable"})");
+
+  // Connections: Main (Debugger disabled), Secondary (Debugger enabled)
+  // --> Only the secondary connection receives Debugger events.
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AllOf(
+          AtJsonPtr("/method", "Debugger.scriptParsed"),
+          AtJsonPtr("/params/url", "script3.js")))));
+  this->eval("3 + 3; //# sourceURL=script3.js");
+
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 4, "result": {}})")));
+  secondary.toPage().sendMessage(R"({"id": 4, "method": "Debugger.disable"})");
+}
 
 TYPED_TEST(JsiIntegrationHermesTest, CDPAgentReentrancyRegressionTest) {
   this->connect();

package/ReactCommon/jsinspector-modern/tests/NetworkReporterTest.cpp

@@ -588,6 +588,40 @@ TEST_P(NetworkReporterTest, testCreateRequestIdWithoutNetworkDomain) {
   EXPECT_NE(id1, id2);
 }
 
+TEST_P(NetworkReporterTest, testTwoSessionsReceiveNetworkEvents) {
+  auto secondary = this->connectSecondary();
+
+  this->expectMessageFromPage(JsonEq(R"({"id": 1, "result": {}})"));
+  this->toPage_->sendMessage(R"({"id": 1, "method": "Network.enable"})");
+
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 2, "result": {}})")));
+  secondary.toPage().sendMessage(R"({"id": 2, "method": "Network.enable"})");
+
+  // Both sessions should receive the network event
+  this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Network.requestWillBeSent"),
+      AtJsonPtr("/params/requestId", "multi-session-request"))));
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AllOf(
+          AtJsonPtr("/method", "Network.requestWillBeSent"),
+          AtJsonPtr("/params/requestId", "multi-session-request")))));
+
+  RequestInfo requestInfo;
+  requestInfo.url = "https://example.com/test";
+  requestInfo.httpMethod = "GET";
+  NetworkReporter::getInstance().reportRequestStart(
+      "multi-session-request", requestInfo, 0, std::nullopt);
+
+  this->expectMessageFromPage(JsonEq(R"({"id": 3, "result": {}})"));
+  this->toPage_->sendMessage(R"({"id": 3, "method": "Network.disable"})");
+
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 4, "result": {}})")));
+  secondary.toPage().sendMessage(R"({"id": 4, "method": "Network.disable"})");
+}
+
 struct NetworkReporterTracingTestParams {
   bool enableNetworkEventReporting;
   bool enableNetworkDomain;