Add tests for getOrCreateThreadLocalPlugin.

Signed-off-by: Takeshi Yoneda <[email protected]>

Author: mathetake

test/BUILD

@@ -78,9 +78,13 @@ cc_test(
 )
 
 cc_test(
-    name = "context_test",
-    srcs = ["context_test.cc"],
+    name = "wasm_test",
+    srcs = ["wasm_test.cc"],
+    data = [
+        "//test/test_data:abi_export.wasm",
+    ],
     deps = [
+        ":utility_lib",
         "//:lib",
         "@com_google_googletest//:gtest",
         "@com_google_googletest//:gtest_main",

test/bytecode_util_test.cc

@@ -59,7 +59,14 @@ TEST(TestBytecodeUtil, getFunctionNameIndex) {
   // OK.
   EXPECT_TRUE(BytecodeUtil::getFunctionNameIndex(source, actual));
   EXPECT_FALSE(actual.empty());
-  EXPECT_EQ(actual.find(0)->second, "proxy_abi_version_0_2_0");
+  bool abi_version_found = false;
+  for (auto it : actual) {
+    if (it.second == "proxy_abi_version_0_2_0") {
+      abi_version_found = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(abi_version_found);
 
   // Fail due to the corrupted bytecode.
   // TODO(@mathetake): here we haven't covered all the parsing failure branches. Add more cases.

test/context_test.cc

@@ -49,10 +49,10 @@ class TestContext : public ContextBase {
 
 TEST_P(TestVM, Environment) {
   std::unordered_map<std::string, std::string> envs = {{"KEY1", "VALUE1"}, {"KEY2", "VALUE2"}};
-  initialize("env.wasm");
+  auto source = readTestWasmFile("env.wasm");
 
   auto wasm_base = WasmBase(std::move(vm_), "vm_id", "", "", envs, {});
-  ASSERT_TRUE(wasm_base.wasm_vm()->load(source_, {}, {}));
+  ASSERT_TRUE(wasm_base.wasm_vm()->load(source, {}, {}));
 
   TestContext context(&wasm_base);
   current_context_ = &context;
@@ -72,9 +72,9 @@ TEST_P(TestVM, Environment) {
 }
 
 TEST_P(TestVM, WithoutEnvironment) {
-  initialize("env.wasm");
+  auto source = readTestWasmFile("env.wasm");
   auto wasm_base = WasmBase(std::move(vm_), "vm_id", "", "", {}, {});
-  ASSERT_TRUE(wasm_base.wasm_vm()->load(source_, {}, {}));
+  ASSERT_TRUE(wasm_base.wasm_vm()->load(source, {}, {}));
 
   TestContext context(&wasm_base);
   current_context_ = &context;
@@ -92,9 +92,9 @@ TEST_P(TestVM, WithoutEnvironment) {
 }
 
 TEST_P(TestVM, Clock) {
-  initialize("clock.wasm");
+  auto source = readTestWasmFile("clock.wasm");
   auto wasm_base = WasmBase(std::move(vm_), "vm_id", "", "", {}, {});
-  ASSERT_TRUE(wasm_base.wasm_vm()->load(source_, {}, {}));
+  ASSERT_TRUE(wasm_base.wasm_vm()->load(source, {}, {}));
 
   TestContext context(&wasm_base);
   current_context_ = &context;

test/exports_test.cc

@@ -47,8 +47,8 @@ TEST_P(TestVM, Basic) {
 }
 
 TEST_P(TestVM, Memory) {
-  initialize("abi_export.wasm");
-  ASSERT_TRUE(vm_->load(source_, {}, {}));
+  auto source = readTestWasmFile("abi_export.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
   ASSERT_TRUE(vm_->link(""));
 
   Word word;
@@ -68,8 +68,8 @@ TEST_P(TestVM, Clone) {
   if (vm_->cloneable() == proxy_wasm::Cloneable::NotCloneable) {
     return;
   }
-  initialize("abi_export.wasm");
-  ASSERT_TRUE(vm_->load(source_, {}, {}));
+  auto source = readTestWasmFile("abi_export.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
   ASSERT_TRUE(vm_->link(""));
   const auto address = 0x2000;
   Word word;
@@ -113,8 +113,10 @@ TEST_P(TestVM, StraceLogLevel) {
     // See https://github.com/proxy-wasm/proxy-wasm-cpp-host/issues/120.
     return;
   }
-  initialize("callback.wasm");
-  ASSERT_TRUE(vm_->load(source_, {}, {}));
+
+  auto integration = static_cast<DummyIntegration *>(vm_->integration().get());
+  auto source = readTestWasmFile("callback.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
   vm_->registerCallback("env", "callback", &nopCallback,
                         &ConvertFunctionWordToUint32<decltype(nopCallback),
                                                      nopCallback>::convertFunctionWordToUint32);
@@ -128,16 +130,16 @@ TEST_P(TestVM, StraceLogLevel) {
 
   run(nullptr);
   // no trace message found since DummyIntegration's log_level_ defaults to  LogLevel::info
-  EXPECT_EQ(integration_->trace_message_, "");
+  EXPECT_EQ(integration->trace_message_, "");
 
-  integration_->log_level_ = LogLevel::trace;
+  integration->log_level_ = LogLevel::trace;
   run(nullptr);
-  EXPECT_NE(integration_->trace_message_, "");
+  EXPECT_NE(integration->trace_message_, "");
 }
 
 TEST_P(TestVM, Callback) {
-  initialize("callback.wasm");
-  ASSERT_TRUE(vm_->load(source_, {}, {}));
+  auto source = readTestWasmFile("callback.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
 
   TestContext context;
 
@@ -166,16 +168,17 @@ TEST_P(TestVM, Callback) {
 }
 
 TEST_P(TestVM, Trap) {
-  initialize("trap.wasm");
-  ASSERT_TRUE(vm_->load(source_, {}, {}));
+  auto source = readTestWasmFile("trap.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
   ASSERT_TRUE(vm_->link(""));
   TestContext context;
   WasmCallVoid<0> trigger;
   vm_->getFunction("trigger", &trigger);
   EXPECT_TRUE(trigger != nullptr);
   trigger(&context);
   std::string exp_message = "Function: trigger failed";
-  ASSERT_TRUE(integration_->error_message_.find(exp_message) != std::string::npos);
+  auto integration = static_cast<DummyIntegration *>(vm_->integration().get());
+  ASSERT_TRUE(integration->error_message_.find(exp_message) != std::string::npos);
 }
 
 TEST_P(TestVM, Trap2) {
@@ -185,16 +188,17 @@ TEST_P(TestVM, Trap2) {
     // WAVM::Runtime::describeCallStack. Needs further investigation.
     return;
   }
-  initialize("trap.wasm");
-  ASSERT_TRUE(vm_->load(source_, {}, {}));
+  auto source = readTestWasmFile("trap.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
   ASSERT_TRUE(vm_->link(""));
   TestContext context;
   WasmCallWord<1> trigger2;
   vm_->getFunction("trigger2", &trigger2);
   EXPECT_TRUE(trigger2 != nullptr);
   trigger2(&context, 0);
   std::string exp_message = "Function: trigger2 failed";
-  ASSERT_TRUE(integration_->error_message_.find(exp_message) != std::string::npos);
+  auto integration = static_cast<DummyIntegration *>(vm_->integration().get());
+  ASSERT_TRUE(integration->error_message_.find(exp_message) != std::string::npos);
 }
 
 } // namespace

test/runtime_test.cc

@@ -14,3 +14,21 @@
 
 #[no_mangle]
 pub extern "C" fn proxy_abi_version_0_2_0() {}
+
+#[no_mangle]
+pub extern "C" fn proxy_on_vm_start(_: u32, _: usize) -> bool {
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn proxy_on_context_create(_: u32, _: u32) {}
+
+#[no_mangle]
+pub extern "C" fn proxy_on_memory_allocate(size: usize) -> *mut u8 {
+    let mut vec: Vec<u8> = Vec::with_capacity(size);
+    unsafe {
+        vec.set_len(size);
+    }
+    let slice = vec.into_boxed_slice();
+    Box::into_raw(slice) as *mut u8
+}

test/test_data/abi_export.rs

@@ -67,37 +67,39 @@ class TestVM : public testing::TestWithParam<std::string> {
 public:
   std::unique_ptr<proxy_wasm::WasmVm> vm_;
 
-  TestVM() : integration_(new DummyIntegration{}) {
+  TestVM() {
     runtime_ = GetParam();
+    vm_ = newVm();
+  }
+
+  std::unique_ptr<proxy_wasm::WasmVm> newVm() {
+    std::unique_ptr<proxy_wasm::WasmVm> vm;
     if (runtime_ == "") {
       EXPECT_TRUE(false) << "runtime must not be empty";
 #if defined(PROXY_WASM_HAS_RUNTIME_V8)
     } else if (runtime_ == "v8") {
-      vm_ = proxy_wasm::createV8Vm();
+      vm = proxy_wasm::createV8Vm();
 #endif
 #if defined(PROXY_WASM_HAS_RUNTIME_WAVM)
     } else if (runtime_ == "wavm") {
-      vm_ = proxy_wasm::createWavmVm();
+      vm = proxy_wasm::createWavmVm();
 #endif
 #if defined(PROXY_WASM_HAS_RUNTIME_WASMTIME)
     } else if (runtime_ == "wasmtime") {
-      vm_ = proxy_wasm::createWasmtimeVm();
+      vm = proxy_wasm::createWasmtimeVm();
 #endif
 #if defined(PROXY_WASM_HAS_RUNTIME_WAMR)
     } else if (runtime_ == "wamr") {
-      vm_ = proxy_wasm::createWamrVm();
+      vm = proxy_wasm::createWamrVm();
 #endif
     } else {
       EXPECT_TRUE(false) << "compiled without support for the requested \"" << runtime_
                          << "\" runtime";
     }
-    vm_->integration().reset(integration_);
-  }
-
-  void initialize(std::string filename) { source_ = readTestWasmFile(filename); }
+    vm->integration().reset(new DummyIntegration{});
+    return vm;
+  };
 
-  DummyIntegration *integration_;
-  std::string source_;
   std::string runtime_;
 };
 } // namespace proxy_wasm

test/utility.h

@@ -0,0 +1,99 @@
+// Copyright 2020 Google LLC
+//
+// Licensed 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.
+
+#include "include/proxy-wasm/wasm.h"
+
+#include "gtest/gtest.h"
+
+#include "test/utility.h"
+
+namespace proxy_wasm {
+
+auto test_values = testing::ValuesIn(getRuntimes());
+
+INSTANTIATE_TEST_SUITE_P(Runtimes, TestVM, test_values);
+
+// Failcallbacks only used for runtimes - not available for nullvm.
+TEST_P(TestVM, GetOrCreateThreadLocalWasmFailCallbacks) {
+  const auto plugin_name = "plugin_name";
+  const auto root_id = "root_id";
+  const auto vm_id = "vm_id";
+  const auto plugin_config = "plugin_config";
+  const auto fail_open = false;
+
+  // Create a plugin.
+  const auto plugin = std::make_shared<PluginBase>(plugin_name, root_id, vm_id, runtime_,
+                                                   plugin_config, fail_open, "plugin_key");
+
+  // Define callbacks.
+  WasmHandleFactory wasm_handle_factory =
+      [this](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
+    auto base_wasm = std::make_shared<WasmBase>(newVm(), "vm_id", "vm_config", vm_key,
+                                                std::unordered_map<std::string, std::string>{},
+                                                AllowedCapabilitiesMap{});
+    return std::make_shared<WasmHandleBase>(base_wasm);
+  };
+
+  WasmHandleCloneFactory wasm_handle_clone_factory =
+      [this](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(); });
+    return std::make_shared<WasmHandleBase>(wasm);
+  };
+
+  PluginHandleFactory plugin_handle_factory =
+      [](std::shared_ptr<WasmHandleBase> base_wasm,
+         std::shared_ptr<PluginBase> plugin) -> std::shared_ptr<PluginHandleBase> {
+    return std::make_shared<PluginHandleBase>(base_wasm, plugin);
+  };
+
+  // Read the minimal loadable binary.
+  auto source = readTestWasmFile("abi_export.wasm");
+
+  // Create base Wasm via createWasm.
+  auto base_wasm_handle =
+      createWasm("vm_key", source, plugin, wasm_handle_factory, wasm_handle_clone_factory, false);
+  ASSERT_TRUE(base_wasm_handle && base_wasm_handle->wasm());
+
+  // Create a thread local plugin.
+  auto thread_local_plugin = getOrCreateThreadLocalPlugin(
+      base_wasm_handle, plugin, wasm_handle_clone_factory, plugin_handle_factory);
+  ASSERT_TRUE(thread_local_plugin && thread_local_plugin->plugin());
+
+  // Cause runtime crash.
+  thread_local_plugin->wasm()->wasm_vm()->fail(FailState::RuntimeError, "runtime error msg");
+  ASSERT_TRUE(thread_local_plugin->wasm()->isFailed());
+
+  // Create another thread local plugin with the same configuration.
+  // This one should not end up using the failed VM.
+  auto thread_local_plugin_new = getOrCreateThreadLocalPlugin(
+      base_wasm_handle, plugin, wasm_handle_clone_factory, plugin_handle_factory);
+  ASSERT_TRUE(thread_local_plugin_new && thread_local_plugin_new->plugin());
+  ASSERT_FALSE(thread_local_plugin_new->wasm()->isFailed());
+
+  // Cause runtime crash again.
+  thread_local_plugin_new->wasm()->wasm_vm()->fail(FailState::RuntimeError, "runtime error msg");
+  ASSERT_TRUE(thread_local_plugin_new->wasm()->isFailed());
+
+  // This time, create another thread local plugin with *different* plugin key for the same vm_key.
+  // This one also should not end up using the failed VM.
+  const auto plugin2 = std::make_shared<PluginBase>(plugin_name, root_id, vm_id, runtime_,
+                                                    plugin_config, fail_open, "another_plugin_key");
+  auto thread_local_plugin_new2 = getOrCreateThreadLocalPlugin(
+      base_wasm_handle, plugin2, wasm_handle_clone_factory, plugin_handle_factory);
+  ASSERT_TRUE(thread_local_plugin_new2 && thread_local_plugin_new2->plugin());
+  ASSERT_FALSE(thread_local_plugin_new2->wasm()->isFailed());
+}
+
+} // namespace proxy_wasm