feat: add getProperty support to plugin tester (GoogleCloudPlatform#284)

feat: add getProperty support to plugin tester

Signed-off-by: Michael Warres <mpw@google.com>

Author: mpwarres

plugins/test/BUILD

@@ -8,6 +8,7 @@ cc_library(
     srcs = ["framework.cc"],
     hdrs = ["framework.h"],
     deps = [
+        ":runner_cc_proto",
         "@boost//:algorithm",
         "@boost//:dll",
         "@boost//:filesystem",

plugins/test/dynamic_test.cc

@@ -16,6 +16,10 @@
 
 #include "test/dynamic_test.h"
 
+#include <memory>
+#include <string>
+#include <vector>
+
 #include <boost/filesystem/path.hpp>
 
 #include "absl/random/distributions.h"
@@ -135,11 +139,13 @@ class AdditionalStream {
   };
 
   AdditionalStream(std::shared_ptr<proxy_wasm::PluginHandleBase> handle,
+                   const pb::Test* cfg,
                    const TestHttpContext::Headers* request_headers,
                    const TestHttpContext::Headers* response_headers,
                    const std::vector<std::string>* request_body_chunks,
                    const std::vector<std::string>* response_body_chunks)
       : handle_(handle),
+        cfg_(*cfg),
         request_headers_(request_headers),
         response_headers_(response_headers),
         request_body_chunks_(request_body_chunks),
@@ -155,6 +161,7 @@ class AdditionalStream {
 
  private:
   std::shared_ptr<proxy_wasm::PluginHandleBase> handle_;
+  const pb::Test& cfg_;
 
   // These fields are owned by the caller, and assumed to remain valid and not
   // change over the lifetime of the AdditionalStream.
@@ -174,7 +181,7 @@ absl::Status AdditionalStream::Advance() {
   while (true) {  // cycle through actions until one is performed
     switch (next_action_) {
       case NextAction::kCreate:
-        stream_ = std::make_unique<TestHttpContext>(handle_);
+        stream_ = std::make_unique<TestHttpContext>(handle_, &cfg_);
         if (request_body_chunks_ != nullptr) {
           remaining_request_body_chunks_.assign(request_body_chunks_->begin(),
                                                 request_body_chunks_->end());
@@ -321,7 +328,7 @@ void DynamicTest::TestBody() {
   CheckSideEffects("plugin_init", cfg_.plugin_init(), *root_context);
 
   // Initialize stream.
-  auto stream = TestHttpContext(handle);
+  auto stream = TestHttpContext(handle, &cfg_);
   ASSERT_VM_HEALTH("stream_init", handle, stream);
   CheckSideEffects("stream_init", cfg_.stream_init(), stream);
 
@@ -474,7 +481,7 @@ void DynamicTest::BenchStreamLifecycle(benchmark::State& state) {
 
   std::vector<AdditionalStream> additional_streams;
   for (int i = 0; i < env_.num_additional_streams(); ++i) {
-    additional_streams.emplace_back(handle, /*request_headers=*/nullptr,
+    additional_streams.emplace_back(handle, &cfg_, /*request_headers=*/nullptr,
                                     /*response_headers=*/nullptr,
                                     /*request_body_chunks=*/nullptr,
                                     /*response_body_chunks=*/nullptr);
@@ -484,7 +491,7 @@ void DynamicTest::BenchStreamLifecycle(benchmark::State& state) {
   // Benchmark stream initialization and teardown.
   bool first = true;
   for (auto _ : state) {
-    auto stream = TestHttpContext(handle);
+    auto stream = TestHttpContext(handle, &cfg_);
     benchmark::DoNotOptimize(stream);
     BM_RETURN_IF_FAILED(handle);
     stream.TearDown();
@@ -530,9 +537,10 @@ void DynamicTest::BenchHttpHandlers(benchmark::State& state) {
   std::vector<AdditionalStream> additional_streams;
   for (int i = 0; i < env_.num_additional_streams(); ++i) {
     additional_streams.emplace_back(
-      handle, request_headers.has_value() ? &*request_headers : nullptr,
-      response_headers.has_value() ? &*response_headers : nullptr,
-      &*request_body_chunks, &*response_body_chunks);
+        handle, &cfg_,
+        request_headers.has_value() ? &*request_headers : nullptr,
+        response_headers.has_value() ? &*response_headers : nullptr,
+        &*request_body_chunks, &*response_body_chunks);
     // Advance twice, once to create the TestHttpContext and once to perform
     // an HTTP handler callback.
     BM_RETURN_IF_ERROR(additional_streams.back().Advance());
@@ -550,7 +558,7 @@ void DynamicTest::BenchHttpHandlers(benchmark::State& state) {
     // - include stream context create/destroy cost in handler benchmarks
     // - don't hand ownership of body chunks to stream context
     state.PauseTiming();
-    stream.emplace(handle);  // create/destroy TestHttpContext
+    stream.emplace(handle, &cfg_);  // create/destroy TestHttpContext
     std::vector<std::string> request_body_chunks_copies = *request_body_chunks;
     std::vector<std::string> response_body_chunks_copies =
         *response_body_chunks;

plugins/test/framework.cc

@@ -14,9 +14,16 @@
 
 #include "test/framework.h"
 
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include <boost/dll/runtime_symbol_info.hpp>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
 
 namespace service_extensions_samples {
 
@@ -155,6 +162,21 @@ proxy_wasm::WasmResult TestHttpContext::setHeaderMapPairs(
   return proxy_wasm::WasmResult::Ok;
 }
 
+proxy_wasm::WasmResult TestHttpContext::getProperty(std::string_view path,
+                                                    std::string* result) {
+  // Proxy-Wasm SDKs use \0 as a path separator:
+  // https://github.com/proxy-wasm/spec/pull/94
+  std::string translated_path = absl::StrJoin(
+      absl::StrSplit(path, absl::string_view("\0", 1), absl::SkipEmpty()), ".");
+  for (const pb::Property& property : cfg_.properties()) {
+    if (property.path() == translated_path) {
+      *result = property.value();
+      return proxy_wasm::WasmResult::Ok;
+    }
+  }
+  return proxy_wasm::WasmResult::NotFound;
+}
+
 proxy_wasm::WasmResult TestHttpContext::sendLocalResponse(
     uint32_t response_code, std::string_view body_text,
     proxy_wasm::Pairs additional_headers, uint32_t grpc_status,

plugins/test/framework.h

@@ -26,6 +26,7 @@
 #include "gtest/gtest.h"
 #include "include/proxy-wasm/exports.h"
 #include "include/proxy-wasm/wasm.h"
+#include "test/runner.pb.h"
 #include "test/utility.h"
 
 namespace service_extensions_samples {
@@ -130,13 +131,15 @@ class TestContext : public proxy_wasm::TestContext {
 // - size checks
 class TestHttpContext : public TestContext {
  public:
-  TestHttpContext(std::shared_ptr<proxy_wasm::PluginHandleBase> plugin_handle)
+  TestHttpContext(std::shared_ptr<proxy_wasm::PluginHandleBase> plugin_handle,
+                  const pb::Test* cfg)
       : TestContext(plugin_handle->wasm().get(),
                     plugin_handle->wasm()
                         ->getRootContext(plugin_handle->plugin(),
                                          /*allow_closed=*/false)
                         ->id(),
-                    plugin_handle) {
+                    plugin_handle),
+        cfg_(*cfg) {
     this->onCreate();
   }
   ~TestHttpContext() override { TearDown(); }
@@ -172,6 +175,8 @@ class TestHttpContext : public TestContext {
   proxy_wasm::WasmResult setHeaderMapPairs(
       proxy_wasm::WasmHeaderMapType type,
       const proxy_wasm::Pairs& pairs) override;
+  proxy_wasm::WasmResult getProperty(std::string_view path,
+                                    std::string* result) override;
 
   // Ignore failStream, avoid calling unimplemented closeStream.
   void failStream(proxy_wasm::WasmStreamType) override {}
@@ -234,6 +239,7 @@ class TestHttpContext : public TestContext {
   };
 
  private:
+  const pb::Test& cfg_;
   // Ensure that we invoke teardown handlers just once.
   bool torn_down_ = false;
   // State tracked during a headers call. Invalid otherwise.

plugins/test/runner.proto

@@ -32,6 +32,7 @@ message StringMatcher {
   }
 }
 
+// HTTP header.
 message Header {
   string key = 1;
   bytes value = 2;
@@ -90,6 +91,14 @@ message Invocation {
   Expectation result = 2;
 }
 
+// Value to be returned by getProperty() hostcalls when the path matches.
+message Property {
+  // Path that names the property. The '.' char acts as a path segment
+  // separator.
+  string path = 1;
+  bytes value = 2;
+}
+
 // Tests to run for a single HTTP request/response.
 message Test {
   // Unique name to identify test results.
@@ -104,6 +113,9 @@ message Test {
     int32 num_chunks = 10;
     int64 chunk_size = 11;
   }
+  // Properties to return from getProperty() hostcalls in stream-level Wasm
+  // invocations (i.e. HTTP phases, stream_init, and stream_destroy).
+  repeated Property properties = 12;
   // Wasm invocations of various HTTP phases. If multiple phases are provided,
   // they are executed in sequence on the same HttpContext. Each phase specifies
   // its own expectations. If any phase results in an immediate response,