Add log checks for checking the root_id is working properly

Signed-off-by: Ingwon Song <[email protected]>

Author: ingwonsong

include/proxy-wasm/context.h

@@ -315,11 +315,7 @@ class ContextBase : public RootInterface,
   }
 
   // Properties
-  WasmResult getProperty(std::string_view path, std::string *result) override {
-    if (path == "plugin_root_id") {
-      *result = root_id_;
-      return WasmResult::Ok;
-    }
+  WasmResult getProperty(std::string_view /* path */, std::string * /* result */) override {
     return unimplemented();
   }
   WasmResult setProperty(std::string_view /* key */,

test/test_data/configure_check.cc

@@ -22,7 +22,7 @@ class TestRootContext1 : public RootContext {
 public:
   explicit TestRootContext1(uint32_t id, std::string_view root_id) : RootContext(id, root_id) {}
   bool onConfigure(size_t s) override {
-    // LOG_TRACE("onConfigure in TestRootContext1");
+    LOG_TRACE("onConfigure in TestRootContext1");
     return true;
   }
 };
@@ -36,7 +36,7 @@ class TestRootContext2 : public RootContext {
 public:
   explicit TestRootContext2(uint32_t id, std::string_view root_id) : RootContext(id, root_id) {}
   bool onConfigure(size_t s) override {
-    // LOG_TRACE("onConfigure in TestRootContext2");
+    LOG_TRACE("onConfigure in TestRootContext2");
     return true;
   }
 };

test/utility.h

@@ -91,12 +91,22 @@ class TestIntegration : public WasmVmIntegration {
 class TestContext : public ContextBase {
 public:
   TestContext(WasmBase *wasm) : ContextBase(wasm) {}
+  TestContext(WasmBase *wasm, const std::shared_ptr<PluginBase> &plugin)
+      : ContextBase(wasm, plugin) {}
 
   WasmResult log(uint32_t /*log_level*/, std::string_view message) override {
     log_ += std::string(message) + "\n";
     return WasmResult::Ok;
   }
 
+  WasmResult getProperty(std::string_view path, std::string *result) override {
+    if (path == "plugin_root_id") {
+      *result = root_id_;
+      return WasmResult::Ok;
+    }
+    return unimplemented();
+  }
+
   bool isLogEmpty() { return log_.empty(); }
 
   bool isLogged(std::string_view message) { return log_.find(message) != std::string::npos; }
@@ -118,10 +128,37 @@ class TestContext : public ContextBase {
 
 class TestWasm : public WasmBase {
 public:
-  TestWasm(std::unique_ptr<WasmVm> wasm_vm, std::unordered_map<std::string, std::string> envs = {})
-      : WasmBase(std::move(wasm_vm), "", "", "", std::move(envs), {}) {}
+  TestWasm(std::unique_ptr<WasmVm> wasm_vm, std::string_view vm_id,
+           std::string_view vm_configuration, std::string_view vm_key,
+           std::unordered_map<std::string, std::string> envs,
+           AllowedCapabilitiesMap allowed_capabilities)
+      : WasmBase(std::move(wasm_vm), vm_id, vm_configuration, vm_key, std::move(envs),
+                 std::move(allowed_capabilities)) {}
+
+  TestWasm(std::unique_ptr<WasmVm> wasm_vm, std::unordered_map<std::string, std::string> envs)
+      : TestWasm(std::move(wasm_vm), "", "", "", std::move(envs), {}) {}
+
+  TestWasm(std::unique_ptr<WasmVm> wasm_vm) : TestWasm(std::move(wasm_vm), {}) {}
+
+  TestWasm(const std::shared_ptr<WasmHandleBase> &base_wasm_handle, const WasmVmFactory &factory)
+      : TestWasm(base_wasm_handle, factory, nullptr) {}
+
+  TestWasm(const std::shared_ptr<WasmHandleBase> &base_wasm_handle, const WasmVmFactory &factory,
+           std::function<void(TestContext *)> root_context_cb)
+      : WasmBase(base_wasm_handle, factory), root_context_cb_(std::move(root_context_cb)) {}
 
   ContextBase *createVmContext() override { return new TestContext(this); };
+
+  ContextBase *createRootContext(const std::shared_ptr<PluginBase> &plugin) override {
+    auto *ctx = new TestContext(this, plugin);
+    if (root_context_cb_) {
+      root_context_cb_(ctx);
+    }
+    return ctx;
+  }
+
+private:
+  std::function<void(TestContext *)> root_context_cb_;
 };
 
 class TestVm : public testing::TestWithParam<std::string> {

test/wasm_test.cc

@@ -129,7 +129,7 @@ TEST_P(TestVm, AlwaysApplyCanaryForDifferentRootID) {
   // Define callbacks.
   WasmHandleFactory wasm_handle_factory =
       [this, vm_id, vm_config](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
-    auto base_wasm = std::make_shared<WasmBase>(newVm(), vm_id, vm_config, vm_key,
+    auto base_wasm = std::make_shared<TestWasm>(newVm(), vm_id, vm_config, vm_key,
                                                 std::unordered_map<std::string, std::string>{},
                                                 AllowedCapabilitiesMap{});
     return std::make_shared<WasmHandleBase>(base_wasm);
@@ -138,17 +138,20 @@ TEST_P(TestVm, AlwaysApplyCanaryForDifferentRootID) {
   WasmHandleCloneFactory wasm_handle_clone_factory =
       [this](const std::shared_ptr<WasmHandleBase> &base_wasm_handle)
       -> std::shared_ptr<WasmHandleBase> {
-    auto wasm = std::make_shared<WasmBase>(base_wasm_handle,
+    auto wasm = std::make_shared<TestWasm>(base_wasm_handle,
                                            [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
     return std::make_shared<WasmHandleBase>(wasm);
   };
 
   auto canary_count = 0;
+  TestContext *root_context_in_canary = nullptr;
   WasmHandleCloneFactory wasm_handle_clone_factory_for_canary =
-      [&canary_count, this](const std::shared_ptr<WasmHandleBase> &base_wasm_handle)
+      [&canary_count, &root_context_in_canary,
+       this](const std::shared_ptr<WasmHandleBase> &base_wasm_handle)
       -> std::shared_ptr<WasmHandleBase> {
-    auto wasm = std::make_shared<WasmBase>(base_wasm_handle,
-                                           [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
+    auto wasm = std::make_shared<TestWasm>(
+        base_wasm_handle, [this]() -> std::unique_ptr<WasmVm> { return newVm(); },
+        [&root_context_in_canary](TestContext *ctx) { root_context_in_canary = ctx; });
     canary_count++;
     return std::make_shared<WasmHandleBase>(wasm);
   };
@@ -165,22 +168,28 @@ TEST_P(TestVm, AlwaysApplyCanaryForDifferentRootID) {
   // Create a first plugin.
   const auto plugin_1 = std::make_shared<PluginBase>(plugin_name, root_id_1, vm_id, engine_,
                                                      plugin_config, fail_open, plugin_key);
-  // Create base Wasm via createWasm.
+  // Create a base Wasm by createWasm.
   auto base_wasm_handle_1 = createWasm(vm_key, source, plugin_1, wasm_handle_factory,
                                        wasm_handle_clone_factory_for_canary, false);
   ASSERT_TRUE(base_wasm_handle_1 && base_wasm_handle_1->wasm());
 
+  // Check if it ran for root context 1
+  EXPECT_TRUE(root_context_in_canary->isLogged("onConfigure in TestRootContext1"));
+
   // Create a first plugin.
   const auto plugin_2 = std::make_shared<PluginBase>(plugin_name, root_id_2, vm_id, engine_,
                                                      plugin_config, fail_open, plugin_key);
-  // Create base Wasm via createWasm.
+  // Create a base Wasm by createWasm.
   auto base_wasm_handle_2 = createWasm(vm_key, source, plugin_2, wasm_handle_factory,
                                        wasm_handle_clone_factory_for_canary, false);
   ASSERT_TRUE(base_wasm_handle_2 && base_wasm_handle_2->wasm());
 
-  // Base Wasm
+  // Check if it ran for root context 2
+  EXPECT_TRUE(root_context_in_canary->isLogged("onConfigure in TestRootContext2"));
+
+  // Base Wasm should be equal, because the same vm_key is used.
   EXPECT_EQ(base_wasm_handle_1->wasm(), base_wasm_handle_2->wasm());
-  // Plugin key should be different with each other, because root_id is different.
+  // Plugin key should be different with each other, because root_ids are different.
   EXPECT_NE(plugin_1->key(), plugin_2->key());
   // For each create Wasm, canary should be done.
   EXPECT_EQ(canary_count, 2);