Test-server extension: use shared configuration base and test facilities

ci/do_ci.sh

@@ -39,15 +39,15 @@ function do_clang_tidy() {
 
 function do_unit_test_coverage() {
     export TEST_TARGETS="//test/... -//test:python_test"
-    export COVERAGE_THRESHOLD=93.2
+    export COVERAGE_THRESHOLD=94.0
     echo "bazel coverage build with tests ${TEST_TARGETS}"
     test/run_nighthawk_bazel_coverage.sh ${TEST_TARGETS}
     exit 0
 }
 
 function do_integration_test_coverage() {
     export TEST_TARGETS="//test:python_test"
-    export COVERAGE_THRESHOLD=78.0
+    export COVERAGE_THRESHOLD=78.6
     echo "bazel coverage build with tests ${TEST_TARGETS}"
     test/run_nighthawk_bazel_coverage.sh ${TEST_TARGETS}
     exit 0

source/server/http_test_server_filter.cc

@@ -13,60 +13,53 @@ namespace Nighthawk {
 namespace Server {
 
 HttpTestServerDecoderFilterConfig::HttpTestServerDecoderFilterConfig(
-    nighthawk::server::ResponseOptions proto_config)
-    : server_config_(std::move(proto_config)) {}
+    const nighthawk::server::ResponseOptions& proto_config)
+    : FilterConfigurationBase(proto_config, "test-server") {}
 
 HttpTestServerDecoderFilter::HttpTestServerDecoderFilter(
     HttpTestServerDecoderFilterConfigSharedPtr config)
     : config_(std::move(config)) {}
 
 void HttpTestServerDecoderFilter::onDestroy() {}
 
-void HttpTestServerDecoderFilter::sendReply() {
-  if (!json_merge_error_) {
-    std::string response_body(base_config_.response_body_size(), 'a');
-    if (request_headers_dump_.has_value()) {
-      response_body += *request_headers_dump_;
-    }
-    decoder_callbacks_->sendLocalReply(
-        static_cast<Envoy::Http::Code>(200), response_body,
-        [this](Envoy::Http::ResponseHeaderMap& direct_response_headers) {
-          Configuration::applyConfigToResponseHeaders(direct_response_headers, base_config_);
-        },
-        absl::nullopt, "");
-  } else {
-    decoder_callbacks_->sendLocalReply(
-        static_cast<Envoy::Http::Code>(500),
-        fmt::format("test-server didn't understand the request: {}", error_message_), nullptr,
-        absl::nullopt, "");
+void HttpTestServerDecoderFilter::sendReply(const nighthawk::server::ResponseOptions& options) {
+  std::string response_body(options.response_body_size(), 'a');
+  if (request_headers_dump_.has_value()) {
+    response_body += *request_headers_dump_;
   }
+  decoder_callbacks_->sendLocalReply(
+      static_cast<Envoy::Http::Code>(200), response_body,
+      [options](Envoy::Http::ResponseHeaderMap& direct_response_headers) {
+        Configuration::applyConfigToResponseHeaders(direct_response_headers, options);
+      },
+      absl::nullopt, "");
 }
 
 Envoy::Http::FilterHeadersStatus
 HttpTestServerDecoderFilter::decodeHeaders(Envoy::Http::RequestHeaderMap& headers,
                                            bool end_stream) {
-  // TODO(oschaaf): Add functionality to clear fields
-  base_config_ = config_->server_config();
-  const auto* request_config_header = headers.get(TestServer::HeaderNames::get().TestServerConfig);
-  if (request_config_header) {
-    json_merge_error_ = !Configuration::mergeJsonConfig(
-        request_config_header->value().getStringView(), base_config_, error_message_);
-  }
-  if (base_config_.echo_request_headers()) {
-    std::stringstream headers_dump;
-    headers_dump << "\nRequest Headers:\n" << headers;
-    request_headers_dump_ = headers_dump.str();
-  }
+  config_->computeEffectiveConfiguration(headers);
   if (end_stream) {
-    sendReply();
+    if (!config_->maybeSendErrorReply(*decoder_callbacks_)) {
+      const absl::StatusOr<EffectiveFilterConfigurationPtr> effective_config =
+          config_->getEffectiveConfiguration();
+      if (effective_config.value()->echo_request_headers()) {
+        std::stringstream headers_dump;
+        headers_dump << "\nRequest Headers:\n" << headers;
+        request_headers_dump_ = headers_dump.str();
+      }
+      sendReply(*effective_config.value());
+    }
   }
   return Envoy::Http::FilterHeadersStatus::StopIteration;
 }
 
 Envoy::Http::FilterDataStatus HttpTestServerDecoderFilter::decodeData(Envoy::Buffer::Instance&,
                                                                       bool end_stream) {
   if (end_stream) {
-    sendReply();
+    if (!config_->maybeSendErrorReply(*decoder_callbacks_)) {
+      sendReply(*config_->getEffectiveConfiguration().value());
+    }
   }
   return Envoy::Http::FilterDataStatus::StopIterationNoBuffer;
 }

source/server/http_test_server_filter.h

@@ -6,17 +6,15 @@
 
 #include "api/server/response_options.pb.h"
 
+#include "server/http_filter_config_base.h"
+
 namespace Nighthawk {
 namespace Server {
 
 // Basically this is left in as a placeholder for further configuration.
-class HttpTestServerDecoderFilterConfig {
+class HttpTestServerDecoderFilterConfig : public FilterConfigurationBase {
 public:
-  HttpTestServerDecoderFilterConfig(nighthawk::server::ResponseOptions proto_config);
-  const nighthawk::server::ResponseOptions& server_config() { return server_config_; }
-
-private:
-  const nighthawk::server::ResponseOptions server_config_;
+  HttpTestServerDecoderFilterConfig(const nighthawk::server::ResponseOptions& proto_config);
 };
 
 using HttpTestServerDecoderFilterConfigSharedPtr =
@@ -36,12 +34,9 @@ class HttpTestServerDecoderFilter : public Envoy::Http::StreamDecoderFilter {
   void setDecoderFilterCallbacks(Envoy::Http::StreamDecoderFilterCallbacks&) override;
 
 private:
-  void sendReply();
+  void sendReply(const nighthawk::server::ResponseOptions& options);
   const HttpTestServerDecoderFilterConfigSharedPtr config_;
   Envoy::Http::StreamDecoderFilterCallbacks* decoder_callbacks_;
-  nighthawk::server::ResponseOptions base_config_;
-  bool json_merge_error_{false};
-  std::string error_message_;
   absl::optional<std::string> request_headers_dump_;
 };
 

source/server/http_time_tracking_filter.cc

@@ -47,7 +47,8 @@ Envoy::Http::FilterDataStatus HttpTimeTrackingFilter::decodeData(Envoy::Buffer::
 
 Envoy::Http::FilterHeadersStatus
 HttpTimeTrackingFilter::encodeHeaders(Envoy::Http::ResponseHeaderMap& response_headers, bool) {
-  const auto effective_config = config_->getEffectiveConfiguration();
+  const absl::StatusOr<EffectiveFilterConfigurationPtr> effective_config =
+      config_->getEffectiveConfiguration();
   if (effective_config.ok()) {
     const std::string previous_request_delta_in_response_header =
         effective_config.value()->emit_previous_request_delta_in_response_header();