refactor: use rnsandbox namespace for shared C++ classes

Author: Dev Patel

packages/react-native-sandbox/ios/SandboxDelegateWrapper.mm

@@ -1,8 +1,7 @@
 #include "SandboxDelegateWrapper.h"
 #import "SandboxReactNativeDelegate.h"
 
-namespace facebook {
-namespace react {
+namespace rnsandbox {
 
 SandboxDelegateWrapper::SandboxDelegateWrapper(SandboxReactNativeDelegate *delegate) : delegate_(delegate)
 {
@@ -47,5 +46,4 @@
   [delegate_ setAllowedTurboModules:modules];
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace rnsandbox

packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm

@@ -123,7 +123,7 @@ - (void)setOrigin:(std::string)origin
 
   // Unregister old origin if it exists
   if (!_origin.empty()) {
-    auto &registry = SandboxRegistry::getInstance();
+    auto &registry = rnsandbox::SandboxRegistry::getInstance();
     registry.unregister(_origin);
   }
 
@@ -132,8 +132,8 @@ - (void)setOrigin:(std::string)origin
 
   // Register new origin if it's not empty
   if (!_origin.empty()) {
-    auto &registry = SandboxRegistry::getInstance();
-    auto wrapper = std::make_shared<SandboxDelegateWrapper>(self);
+    auto &registry = rnsandbox::SandboxRegistry::getInstance();
+    auto wrapper = std::make_shared<rnsandbox::SandboxDelegateWrapper>(self);
     registry.registerSandbox(_origin, wrapper, _allowedOrigins);
   }
 }
@@ -149,8 +149,8 @@ - (void)setAllowedOrigins:(std::set<std::string>)allowedOrigins
 
   // Re-register with new allowedOrigins if origin is set
   if (!_origin.empty()) {
-    auto &registry = SandboxRegistry::getInstance();
-    auto wrapper = std::make_shared<SandboxDelegateWrapper>(self);
+    auto &registry = rnsandbox::SandboxRegistry::getInstance();
+    auto wrapper = std::make_shared<rnsandbox::SandboxDelegateWrapper>(self);
     registry.registerSandbox(_origin, wrapper, _allowedOrigins);
   }
 }
@@ -163,7 +163,7 @@ - (void)setAllowedTurboModules:(std::set<std::string>)allowedTurboModules
 - (void)dealloc
 {
   if (!_origin.empty()) {
-    auto &registry = SandboxRegistry::getInstance();
+    auto &registry = rnsandbox::SandboxRegistry::getInstance();
     registry.unregister(_origin);
   } else {
     [self cleanupResources];
@@ -238,7 +238,7 @@ - (void)postMessage:(const std::string &)message
 
 - (bool)routeMessage:(const std::string &)message toSandbox:(const std::string &)targetId
 {
-  auto &registry = SandboxRegistry::getInstance();
+  auto &registry = rnsandbox::SandboxRegistry::getInstance();
   auto target = registry.find(targetId);
   if (!target) {
     return false;
@@ -302,7 +302,7 @@ - (void)hostDidStart:(RCTHost *)host
     return [super getTurboModule:name jsInvoker:jsInvoker];
   } else {
     // Return C++ stub instead of nullptr
-    return std::make_shared<facebook::react::StubTurboModuleCxx>(name, jsInvoker);
+    return std::make_shared<rnsandbox::StubTurboModuleCxx>(name, jsInvoker);
   }
 }
 

packages/react-native-sandbox/tests/MockSandboxDelegate.h

@@ -6,8 +6,7 @@
 
 #include <ISandboxDelegate.h>
 
-namespace facebook {
-namespace react {
+namespace rnsandbox {
 
 class MockSandboxDelegate : public ISandboxDelegate {
  public:
@@ -30,5 +29,4 @@ class MockSandboxDelegate : public ISandboxDelegate {
       (override));
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace rnsandbox

packages/react-native-sandbox/tests/SandboxRegistryTest.cpp

@@ -1,4 +1,3 @@
-#include <fmt/format.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <chrono>
@@ -10,7 +9,7 @@
 
 #include "MockSandboxDelegate.h"
 
-using namespace facebook::react;
+using namespace rnsandbox;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
@@ -82,23 +81,66 @@ TEST_F(SandboxRegistryTest, EmptyAllowedOrigins) {
   EXPECT_FALSE(registry.isPermittedFrom("test-origin", "any-origin"));
 }
 
-TEST_F(SandboxRegistryTest, OverwriteExistingSandbox) {
+TEST_F(SandboxRegistryTest, MultipleDelegatesSameOrigin) {
   auto& registry = SandboxRegistry::getInstance();
-  auto mockDelegate1 = std::make_shared<StrictMock<MockSandboxDelegate>>();
-  auto mockDelegate2 = std::make_shared<StrictMock<MockSandboxDelegate>>();
+  auto delegate1 = std::make_shared<StrictMock<MockSandboxDelegate>>();
+  auto delegate2 = std::make_shared<StrictMock<MockSandboxDelegate>>();
 
-  std::set<std::string> allowedOrigins1 = {"allowed1"};
-  std::set<std::string> allowedOrigins2 = {"allowed2"};
+  std::set<std::string> allowedOrigins = {"other"};
+  registry.registerSandbox("shared", delegate1, allowedOrigins);
+  registry.registerSandbox("shared", delegate2, allowedOrigins);
 
-  registry.registerSandbox("test-origin", mockDelegate1, allowedOrigins1);
+  // find returns the first
+  EXPECT_EQ(registry.find("shared"), delegate1);
 
-  registry.registerSandbox("test-origin", mockDelegate2, allowedOrigins2);
+  // findAll returns both
+  auto all = registry.findAll("shared");
+  EXPECT_EQ(all.size(), 2u);
+  EXPECT_EQ(all[0], delegate1);
+  EXPECT_EQ(all[1], delegate2);
+}
 
-  auto found = registry.find("test-origin");
-  EXPECT_EQ(found, mockDelegate2);
+TEST_F(SandboxRegistryTest, UnregisterDelegateRemovesOnlyThatDelegate) {
+  auto& registry = SandboxRegistry::getInstance();
+  auto delegate1 = std::make_shared<StrictMock<MockSandboxDelegate>>();
+  auto delegate2 = std::make_shared<StrictMock<MockSandboxDelegate>>();
 
-  EXPECT_FALSE(registry.isPermittedFrom("allowed2", "test-origin"));
-  EXPECT_FALSE(registry.isPermittedFrom("allowed1", "test-origin"));
+  std::set<std::string> allowedOrigins = {"other"};
+  registry.registerSandbox("shared", delegate1, allowedOrigins);
+  registry.registerSandbox("shared", delegate2, allowedOrigins);
+
+  registry.unregisterDelegate("shared", delegate1);
+
+  auto all = registry.findAll("shared");
+  EXPECT_EQ(all.size(), 1u);
+  EXPECT_EQ(all[0], delegate2);
+  EXPECT_EQ(registry.find("shared"), delegate2);
+}
+
+TEST_F(SandboxRegistryTest, UnregisterDelegateLastCleansUpOrigin) {
+  auto& registry = SandboxRegistry::getInstance();
+  auto delegate = std::make_shared<StrictMock<MockSandboxDelegate>>();
+
+  std::set<std::string> allowedOrigins = {"other"};
+  registry.registerSandbox("solo", delegate, allowedOrigins);
+
+  registry.unregisterDelegate("solo", delegate);
+
+  EXPECT_EQ(registry.find("solo"), nullptr);
+  EXPECT_TRUE(registry.findAll("solo").empty());
+  EXPECT_FALSE(registry.isPermittedFrom("solo", "other"));
+}
+
+TEST_F(SandboxRegistryTest, DuplicateRegistrationIgnored) {
+  auto& registry = SandboxRegistry::getInstance();
+  auto delegate = std::make_shared<StrictMock<MockSandboxDelegate>>();
+
+  std::set<std::string> allowedOrigins;
+  registry.registerSandbox("dup", delegate, allowedOrigins);
+  registry.registerSandbox("dup", delegate, allowedOrigins);
+
+  auto all = registry.findAll("dup");
+  EXPECT_EQ(all.size(), 1u);
 }
 
 TEST_F(SandboxRegistryTest, EmptyOriginHandling) {
@@ -167,7 +209,7 @@ TEST_F(SandboxRegistryTest, ThreadSafety) {
             EXPECT_TRUE(registry.isPermittedFrom(origin, "other_sandbox"));
             EXPECT_FALSE(registry.isPermittedFrom(origin, "blocked_sandbox"));
 
-            registry.unregister(origin);
+            registry.unregisterDelegate(origin, mockDelegate);
 
             auto notFound = registry.find(origin);
             EXPECT_EQ(notFound, nullptr);
@@ -180,4 +222,4 @@ TEST_F(SandboxRegistryTest, ThreadSafety) {
     EXPECT_EQ(status, std::future_status::ready)
         << "Thread safety test timed out after 5 seconds";
   }
-}
+}