Enable proto schema for router_check_tool (envoyproxy#6992)

Signed-off-by: Jyoti Mahapatra <[email protected]>

Author: jyotima

docs/root/install/tools/route_table_check_tool.rst

@@ -18,6 +18,16 @@ Input
      :ref:`config <config_tools_router_check_tool>`.
      The tool config input file specifies urls (composed of authorities and paths)
      and expected route parameter values. Additional parameters such as additional headers are optional.
+     Schema: All internal schemas in the tool are based on :repo:`proto3 <test/tools/router_check/validation.proto>`.
+     This is enabled by an extra optional parameter ``--useproto``. This parameter will become the default in the future releases and enables more validation features in the tool.
+     Any new feature addition in validations will be added behind this parameter.
+     Migration: If you are currently using the tool and plan to migrate to use ``--useproto``, change the yaml/json test's schema based on the :repo:`proto <test/tools/router_check/validation.proto>`.
+     Few known changes necessary are:
+     ``:authority`` input is now ``authority``.
+     ``:path`` input is now ``path``.
+     ``:method`` input is now ``method``. This is a required property.
+     ``additional_headers`` in the input along with ``header_fields`` and ``custom_header_fields`` contain ``key`` instead of ``field``.
+     ``tests`` is a root level field in the yaml/json.
 
 Output
   The program exits with status EXIT_FAILURE if any test case does not match the expected route parameter
@@ -52,12 +62,15 @@ Running
   expected order of command line arguments is:
   1. The router configuration file.
   2. The tool configuration json file.
-  3. The optional details flag. ::
+  3. ``--useproto`` to use any new features in the tool.
+  4. The optional details flag. ::
 
     bazel-bin/test/tools/router_check/router_check_tool router_config.(yaml|json) tool_config.json
 
     bazel-bin/test/tools/router_check/router_check_tool router_config.(yaml|json) tool_config.json --details
 
+    bazel-bin/test/tools/router_check/router_check_tool router_config.(yaml|json) tool_config.json --details --useproto
+
 Testing
   A bash shell script test can be run with bazel. The test compares routes using different router and
   tool configuration files. The configuration files can be found in

docs/root/intro/deprecated.rst

@@ -14,6 +14,7 @@ Version 1.11.0 (Pending)
 ========================
 * The --max-stats and --max-obj-name-len flags no longer has any effect.
 * Use of :ref:`cluster <envoy_api_field_config.filter.network.redis_proxy.v2.RedisProxy.cluster>` in :ref:`redis_proxy.proto <envoy_api_file_envoy/config/filter/network/redis_proxy/v2/redis_proxy.proto>` is deprecated. Set a :ref:`catch_all_cluster <envoy_api_field_config.filter.network.redis_proxy.v2.RedisProxy.PrefixRoutes.catch_all_cluster>` instead.
+* Use of json based schema in router check tool tests. The tests should follow validation :repo:`schema<test/tools/router_check/validation.proto>`.
 
 Version 1.10.0 (Apr 5, 2019)
 ============================

docs/root/intro/version_history.rst

@@ -38,6 +38,7 @@ Version history
 * sandbox: added :ref:`CSRF sandbox <install_sandboxes_csrf>`.
 * server: ``--define manual_stamp=manual_stamp`` was added to allow server stamping outside of binary rules.
   more info in the `bazel docs <https://github.com/envoyproxy/envoy/blob/master/bazel/README.md#enabling-optional-features>`_.
+* tool: added :repo:`proto <test/tools/router_check/validation.proto>` support for :ref:`router check tool <install_tools_route_table_check_tool>` tests.
 * upstream: added :ref:`upstream_cx_pool_overflow <config_cluster_manager_cluster_stats>` for the connection pool circuit breaker.
 * upstream: an EDS management server can now force removal of a host that is still passing active
   health checking by first marking the host as failed via EDS health check and subsequently removing

test/tools/router_check/BUILD

@@ -5,6 +5,7 @@ load(
     "envoy_cc_test_binary",
     "envoy_cc_test_library",
     "envoy_package",
+    "envoy_proto_library",
 )
 
 envoy_package()
@@ -22,6 +23,7 @@ envoy_cc_test_library(
         "router.h",
     ],
     deps = [
+        ":validation_proto_cc",
         "//source/common/config:rds_json_lib",
         "//source/common/event:dispatcher_lib",
         "//source/common/http:header_map_lib",
@@ -35,3 +37,9 @@ envoy_cc_test_library(
         "//test/tools/router_check/json:tool_config_schemas_lib",
     ],
 )
+
+envoy_proto_library(
+    name = "validation_proto",
+    srcs = ["validation.proto"],
+    deps = ["@envoy_api//envoy/api/v2/core:base_export"],
+)

test/tools/router_check/router.cc

@@ -37,6 +37,28 @@ ToolConfig ToolConfig::create(const Json::ObjectSharedPtr check_config) {
   return ToolConfig(std::move(headers), random_value);
 }
 
+ToolConfig ToolConfig::create(const envoy::RouterCheckToolSchema::ValidationItem& check_config) {
+  // Add header field values
+  std::unique_ptr<Http::TestHeaderMapImpl> headers(new Http::TestHeaderMapImpl());
+  headers->addCopy(":authority", check_config.input().authority());
+  headers->addCopy(":path", check_config.input().path());
+  headers->addCopy(":method", check_config.input().method());
+  headers->addCopy("x-forwarded-proto", check_config.input().ssl() ? "https" : "http");
+
+  if (check_config.input().internal()) {
+    headers->addCopy("x-envoy-internal", "true");
+  }
+
+  if (check_config.input().additional_headers().data()) {
+    for (const envoy::api::v2::core::HeaderValue& header_config :
+         check_config.input().additional_headers()) {
+      headers->addCopy(header_config.key(), header_config.value());
+    }
+  }
+
+  return ToolConfig(std::move(headers), check_config.input().random_value());
+}
+
 ToolConfig::ToolConfig(std::unique_ptr<Http::TestHeaderMapImpl> headers, int random_value)
     : headers_(std::move(headers)), random_value_(random_value) {}
 
@@ -130,6 +152,50 @@ bool RouterCheckTool::compareEntriesInJson(const std::string& expected_route_jso
   return no_failures;
 }
 
+bool RouterCheckTool::compareEntries(const std::string& expected_routes) {
+  envoy::RouterCheckToolSchema::Validation validation_config;
+  auto stats = std::make_unique<Stats::IsolatedStoreImpl>();
+  auto api = Api::createApiForTest(*stats);
+  const std::string contents = api->fileSystem().fileReadToEnd(expected_routes);
+  MessageUtil::loadFromFile(expected_routes, validation_config, *api);
+  MessageUtil::validate(validation_config);
+
+  bool no_failures = true;
+  for (const envoy::RouterCheckToolSchema::ValidationItem& check_config :
+       validation_config.tests()) {
+    ToolConfig tool_config = ToolConfig::create(check_config);
+    tool_config.route_ = config_->route(*tool_config.headers_, tool_config.random_value_);
+
+    std::string test_name = check_config.test_name();
+    if (details_) {
+      std::cout << test_name << std::endl;
+    }
+    envoy::RouterCheckToolSchema::ValidationAssert validate = check_config.validate();
+
+    using checkerFunc =
+        std::function<bool(ToolConfig&, const envoy::RouterCheckToolSchema::ValidationAssert&)>;
+    checkerFunc checkers[] = {
+        [this](auto&... params) -> bool { return this->compareCluster(params...); },
+        [this](auto&... params) -> bool { return this->compareVirtualCluster(params...); },
+        [this](auto&... params) -> bool { return this->compareVirtualHost(params...); },
+        [this](auto&... params) -> bool { return this->compareRewritePath(params...); },
+        [this](auto&... params) -> bool { return this->compareRewriteHost(params...); },
+        [this](auto&... params) -> bool { return this->compareRedirectPath(params...); },
+        [this](auto&... params) -> bool { return this->compareHeaderField(params...); },
+        [this](auto&... params) -> bool { return this->compareCustomHeaderField(params...); },
+    };
+
+    // Call appropriate function for each match case.
+    for (const auto& test : checkers) {
+      if (!test(tool_config, validate)) {
+        no_failures = false;
+      }
+    }
+  }
+
+  return no_failures;
+}
+
 bool RouterCheckTool::compareCluster(ToolConfig& tool_config, const std::string& expected) {
   std::string actual = "";
 
@@ -139,6 +205,17 @@ bool RouterCheckTool::compareCluster(ToolConfig& tool_config, const std::string&
   return compareResults(actual, expected, "cluster_name");
 }
 
+bool RouterCheckTool::compareCluster(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  if (expected.cluster_name().empty()) {
+    return true;
+  }
+  if (tool_config.route_ == nullptr) {
+    return compareResults("", expected.cluster_name(), "cluster_name");
+  }
+  return compareCluster(tool_config, expected.cluster_name());
+}
+
 bool RouterCheckTool::compareVirtualCluster(ToolConfig& tool_config, const std::string& expected) {
   std::string actual = "";
 
@@ -151,6 +228,17 @@ bool RouterCheckTool::compareVirtualCluster(ToolConfig& tool_config, const std::
   return compareResults(actual, expected, "virtual_cluster_name");
 }
 
+bool RouterCheckTool::compareVirtualCluster(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  if (expected.virtual_cluster_name().empty()) {
+    return true;
+  }
+  if (tool_config.route_ == nullptr) {
+    return compareResults("", expected.virtual_cluster_name(), "virtual_cluster_name");
+  }
+  return compareVirtualCluster(tool_config, expected.virtual_cluster_name());
+}
+
 bool RouterCheckTool::compareVirtualHost(ToolConfig& tool_config, const std::string& expected) {
   std::string actual = "";
   if (tool_config.route_->routeEntry() != nullptr) {
@@ -160,6 +248,17 @@ bool RouterCheckTool::compareVirtualHost(ToolConfig& tool_config, const std::str
   return compareResults(actual, expected, "virtual_host_name");
 }
 
+bool RouterCheckTool::compareVirtualHost(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  if (expected.virtual_host_name().empty()) {
+    return true;
+  }
+  if (tool_config.route_ == nullptr) {
+    return compareResults("", expected.virtual_host_name(), "virtual_host_name");
+  }
+  return compareVirtualHost(tool_config, expected.virtual_host_name());
+}
+
 bool RouterCheckTool::compareRewritePath(ToolConfig& tool_config, const std::string& expected) {
   std::string actual = "";
   Envoy::StreamInfo::StreamInfoImpl stream_info(Envoy::Http::Protocol::Http11,
@@ -172,6 +271,17 @@ bool RouterCheckTool::compareRewritePath(ToolConfig& tool_config, const std::str
   return compareResults(actual, expected, "path_rewrite");
 }
 
+bool RouterCheckTool::compareRewritePath(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  if (expected.path_rewrite().empty()) {
+    return true;
+  }
+  if (tool_config.route_ == nullptr) {
+    return compareResults("", expected.path_rewrite(), "path_rewrite");
+  }
+  return compareRewritePath(tool_config, expected.path_rewrite());
+}
+
 bool RouterCheckTool::compareRewriteHost(ToolConfig& tool_config, const std::string& expected) {
   std::string actual = "";
   Envoy::StreamInfo::StreamInfoImpl stream_info(Envoy::Http::Protocol::Http11,
@@ -184,6 +294,17 @@ bool RouterCheckTool::compareRewriteHost(ToolConfig& tool_config, const std::str
   return compareResults(actual, expected, "host_rewrite");
 }
 
+bool RouterCheckTool::compareRewriteHost(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  if (expected.host_rewrite().empty()) {
+    return true;
+  }
+  if (tool_config.route_ == nullptr) {
+    return compareResults("", expected.host_rewrite(), "host_rewrite");
+  }
+  return compareRewriteHost(tool_config, expected.host_rewrite());
+}
+
 bool RouterCheckTool::compareRedirectPath(ToolConfig& tool_config, const std::string& expected) {
   std::string actual = "";
   if (tool_config.route_->directResponseEntry() != nullptr) {
@@ -193,6 +314,30 @@ bool RouterCheckTool::compareRedirectPath(ToolConfig& tool_config, const std::st
   return compareResults(actual, expected, "path_redirect");
 }
 
+bool RouterCheckTool::compareRedirectPath(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  if (expected.path_redirect().empty()) {
+    return true;
+  }
+  if (tool_config.route_ == nullptr) {
+    return compareResults("", expected.path_redirect(), "path_redirect");
+  }
+  return compareRedirectPath(tool_config, expected.path_redirect());
+}
+
+bool RouterCheckTool::compareHeaderField(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  bool no_failures = true;
+  if (expected.header_fields().data()) {
+    for (const envoy::api::v2::core::HeaderValue& header : expected.header_fields()) {
+      if (!compareHeaderField(tool_config, header.key(), header.value())) {
+        no_failures = false;
+      }
+    }
+  }
+  return no_failures;
+}
+
 bool RouterCheckTool::compareHeaderField(ToolConfig& tool_config, const std::string& field,
                                          const std::string& expected) {
   std::string actual = tool_config.headers_->get_(field);
@@ -213,6 +358,19 @@ bool RouterCheckTool::compareCustomHeaderField(ToolConfig& tool_config, const st
   return compareResults(actual, expected, "custom_header");
 }
 
+bool RouterCheckTool::compareCustomHeaderField(
+    ToolConfig& tool_config, const envoy::RouterCheckToolSchema::ValidationAssert& expected) {
+  bool no_failures = true;
+  if (expected.custom_header_fields().data()) {
+    for (const envoy::api::v2::core::HeaderValue& header : expected.custom_header_fields()) {
+      if (!compareCustomHeaderField(tool_config, header.key(), header.value())) {
+        no_failures = false;
+      }
+    }
+  }
+  return no_failures;
+}
+
 bool RouterCheckTool::compareResults(const std::string& actual, const std::string& expected,
                                      const std::string& test_type) {
   if (expected == actual) {

test/tools/router_check/router.h

@@ -3,6 +3,8 @@
 #include <memory>
 #include <string>
 
+#include "envoy/api/v2/core/base.pb.h"
+
 #include "common/common/logger.h"
 #include "common/common/utility.h"
 #include "common/http/header_map_impl.h"
@@ -16,6 +18,8 @@
 #include "test/test_common/printers.h"
 #include "test/test_common/utility.h"
 #include "test/tools/router_check/json/tool_config_schemas.h"
+#include "test/tools/router_check/validation.pb.h"
+#include "test/tools/router_check/validation.pb.validate.h"
 
 namespace Envoy {
 /**
@@ -32,6 +36,13 @@ struct ToolConfig {
    */
   static ToolConfig create(const Json::ObjectSharedPtr check_config);
 
+  /**
+   * @param check_config tool config proto object.
+   * @return ToolConfig a ToolConfig instance with member variables set by the tool config json
+   * file.
+   */
+  static ToolConfig create(const envoy::RouterCheckToolSchema::ValidationItem& check_config);
+
   Stats::SymbolTable& symbolTable() { return *symbol_table_; }
 
   std::unique_ptr<Http::TestHeaderMapImpl> headers_;
@@ -64,6 +75,12 @@ class RouterCheckTool : Logger::Loggable<Logger::Id::testing> {
    */
   bool compareEntriesInJson(const std::string& expected_route_json);
 
+  /**
+   * @param expected_route_json tool config json file.
+   * @return bool if all routes match what is expected.
+   */
+  bool compareEntries(const std::string& expected_routes);
+
   /**
    * Set whether to print out match case details.
    */
@@ -76,15 +93,31 @@ class RouterCheckTool : Logger::Loggable<Logger::Id::testing> {
       Api::ApiPtr api);
 
   bool compareCluster(ToolConfig& tool_config, const std::string& expected);
+  bool compareCluster(ToolConfig& tool_config,
+                      const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareVirtualCluster(ToolConfig& tool_config, const std::string& expected);
+  bool compareVirtualCluster(ToolConfig& tool_config,
+                             const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareVirtualHost(ToolConfig& tool_config, const std::string& expected);
+  bool compareVirtualHost(ToolConfig& tool_config,
+                          const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareRewriteHost(ToolConfig& tool_config, const std::string& expected);
+  bool compareRewriteHost(ToolConfig& tool_config,
+                          const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareRewritePath(ToolConfig& tool_config, const std::string& expected);
+  bool compareRewritePath(ToolConfig& tool_config,
+                          const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareRedirectPath(ToolConfig& tool_config, const std::string& expected);
+  bool compareRedirectPath(ToolConfig& tool_config,
+                           const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareHeaderField(ToolConfig& tool_config, const std::string& field,
                           const std::string& expected);
+  bool compareHeaderField(ToolConfig& tool_config,
+                          const envoy::RouterCheckToolSchema::ValidationAssert& expected);
   bool compareCustomHeaderField(ToolConfig& tool_config, const std::string& field,
                                 const std::string& expected);
+  bool compareCustomHeaderField(ToolConfig& tool_config,
+                                const envoy::RouterCheckToolSchema::ValidationAssert& expecte);
   /**
    * Compare the expected and actual route parameter values. Print out match details if details_
    * flag is set.