Refactor OverloadIntegrationTest

test/integration/BUILD

@@ -1094,11 +1094,43 @@ envoy_cc_test(
     ],
 )
 
+envoy_cc_test_library(
+    name = "fake_resource_monitor_lib",
+    srcs = [
+        "fake_resource_monitor.cc",
+    ],
+    hdrs = [
+        "fake_resource_monitor.h",
+    ],
+    deps = [
+        "//envoy/server:resource_monitor_config_interface",
+        "//test/common/config:dummy_config_proto_cc_proto",
+    ],
+)
+
+envoy_cc_test_library(
+    name = "base_overload_integration_test_lib",
+    srcs = [
+        "base_overload_integration_test.cc",
+    ],
+    hdrs = [
+        "base_overload_integration_test.h",
+    ],
+    deps = [
+        ":fake_resource_monitor_lib",
+        "//test/test_common:registry_lib",
+        "//test/test_common:utility_lib",
+        "@envoy_api//envoy/config/bootstrap/v3:pkg_cc_proto",
+        "@envoy_api//envoy/config/overload/v3:pkg_cc_proto",
+    ],
+)
+
 envoy_cc_test(
     name = "overload_integration_test",
     srcs = ["overload_integration_test.cc"],
     shard_count = 2,
     deps = [
+        ":base_overload_integration_test_lib",
         ":http_protocol_integration_lib",
         "//test/common/config:dummy_config_proto_cc_proto",
         "@envoy_api//envoy/config/bootstrap/v3:pkg_cc_proto",

test/integration/base_overload_integration_test.cc

@@ -0,0 +1,23 @@
+#include "test/integration/base_overload_integration_test.h"
+
+#include "test/test_common/utility.h"
+
+namespace Envoy {
+
+void BaseOverloadIntegrationTest::setupOverloadManagerConfig(
+    const envoy::config::overload::v3::OverloadAction& overload_action) {
+  const std::string overload_config = R"EOF(
+        refresh_interval:
+          seconds: 0
+          nanos: 1000000
+        resource_monitors:
+          - name: "envoy.resource_monitors.testonly.fake_resource_monitor"
+            typed_config:
+              "@type": type.googleapis.com/google.protobuf.Empty
+      )EOF";
+  overload_manager_config_ =
+      TestUtility::parseYaml<envoy::config::overload::v3::OverloadManager>(overload_config);
+  *overload_manager_config_.add_actions() = overload_action;
+}
+
+} // namespace Envoy

test/integration/base_overload_integration_test.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "envoy/config/bootstrap/v3/bootstrap.pb.h"
+#include "envoy/config/overload/v3/overload.pb.h"
+
+#include "test/integration/fake_resource_monitor.h"
+#include "test/test_common/registry.h"
+
+namespace Envoy {
+
+class BaseOverloadIntegrationTest {
+protected:
+  void
+  setupOverloadManagerConfig(const envoy::config::overload::v3::OverloadAction& overload_action);
+
+  void updateResource(double pressure) {
+    auto* monitor = fake_resource_monitor_factory_.monitor();
+    ASSERT(monitor != nullptr);
+    monitor->setResourcePressure(pressure);
+  }
+
+  envoy::config::overload::v3::OverloadManager overload_manager_config_;
+  FakeResourceMonitorFactory fake_resource_monitor_factory_;
+  Registry::InjectFactory<Server::Configuration::ResourceMonitorFactory> inject_factory_{
+      fake_resource_monitor_factory_};
+};
+
+} // namespace Envoy

test/integration/fake_resource_monitor.cc

@@ -0,0 +1,24 @@
+#include "test/integration/fake_resource_monitor.h"
+
+namespace Envoy {
+
+FakeResourceMonitor::~FakeResourceMonitor() { factory_.onMonitorDestroyed(this); }
+
+void FakeResourceMonitor::updateResourceUsage(Callbacks& callbacks) {
+  Server::ResourceUsage usage;
+  usage.resource_pressure_ = pressure_;
+  callbacks.onSuccess(usage);
+}
+
+void FakeResourceMonitorFactory::onMonitorDestroyed(FakeResourceMonitor* monitor) {
+  ASSERT(monitor_ == monitor);
+  monitor_ = nullptr;
+}
+Server::ResourceMonitorPtr FakeResourceMonitorFactory::createResourceMonitor(
+    const Protobuf::Message&, Server::Configuration::ResourceMonitorFactoryContext& context) {
+  auto monitor = std::make_unique<FakeResourceMonitor>(context.dispatcher(), *this);
+  monitor_ = monitor.get();
+  return monitor;
+}
+
+} // namespace Envoy

test/integration/fake_resource_monitor.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "envoy/server/resource_monitor.h"
+#include "envoy/server/resource_monitor_config.h"
+
+#include "test/common/config/dummy_config.pb.h"
+
+namespace Envoy {
+
+class FakeResourceMonitorFactory;
+
+class FakeResourceMonitor : public Server::ResourceMonitor {
+public:
+  FakeResourceMonitor(Event::Dispatcher& dispatcher, FakeResourceMonitorFactory& factory)
+      : dispatcher_(dispatcher), factory_(factory), pressure_(0.0) {}
+  // Server::ResourceMonitor
+  ~FakeResourceMonitor() override;
+  void updateResourceUsage(Callbacks& callbacks) override;
+
+  void setResourcePressure(double pressure) {
+    dispatcher_.post([this, pressure] { pressure_ = pressure; });
+  }
+
+private:
+  Event::Dispatcher& dispatcher_;
+  FakeResourceMonitorFactory& factory_;
+  double pressure_;
+};
+
+class FakeResourceMonitorFactory : public Server::Configuration::ResourceMonitorFactory {
+public:
+  // Server::Configuration::ResourceMonitorFactory
+  Server::ResourceMonitorPtr
+  createResourceMonitor(const Protobuf::Message& config,
+                        Server::Configuration::ResourceMonitorFactoryContext& context) override;
+
+  ProtobufTypes::MessagePtr createEmptyConfigProto() override {
+    return std::make_unique<test::common::config::DummyConfig>();
+  }
+  std::string name() const override {
+    return "envoy.resource_monitors.testonly.fake_resource_monitor";
+  }
+
+  FakeResourceMonitor* monitor() const { return monitor_; }
+  void onMonitorDestroyed(FakeResourceMonitor* monitor);
+
+private:
+  FakeResourceMonitor* monitor_{nullptr};
+};
+
+} // namespace Envoy

test/integration/overload_integration_test.cc

@@ -2,13 +2,10 @@
 
 #include "envoy/config/bootstrap/v3/bootstrap.pb.h"
 #include "envoy/config/overload/v3/overload.pb.h"
-#include "envoy/server/resource_monitor.h"
-#include "envoy/server/resource_monitor_config.h"
 
-#include "test/common/config/dummy_config.pb.h"
+#include "test/integration/base_overload_integration_test.h"
 #include "test/integration/http_protocol_integration.h"
 #include "test/integration/ssl_utility.h"
-#include "test/test_common/registry.h"
 
 #include "absl/strings/str_cat.h"
 
@@ -18,100 +15,18 @@ namespace Envoy {
 
 using testing::HasSubstr;
 
-class FakeResourceMonitorFactory;
-
-class FakeResourceMonitor : public Server::ResourceMonitor {
-public:
-  FakeResourceMonitor(Event::Dispatcher& dispatcher, FakeResourceMonitorFactory& factory)
-      : dispatcher_(dispatcher), factory_(factory), pressure_(0.0) {}
-  ~FakeResourceMonitor() override;
-  void updateResourceUsage(Callbacks& callbacks) override;
-
-  void setResourcePressure(double pressure) {
-    dispatcher_.post([this, pressure] { pressure_ = pressure; });
-  }
-
-private:
-  Event::Dispatcher& dispatcher_;
-  FakeResourceMonitorFactory& factory_;
-  double pressure_;
-};
-
-class FakeResourceMonitorFactory : public Server::Configuration::ResourceMonitorFactory {
-public:
-  FakeResourceMonitor* monitor() const { return monitor_; }
-  Server::ResourceMonitorPtr
-  createResourceMonitor(const Protobuf::Message& config,
-                        Server::Configuration::ResourceMonitorFactoryContext& context) override;
-
-  ProtobufTypes::MessagePtr createEmptyConfigProto() override {
-    return std::make_unique<test::common::config::DummyConfig>();
-  }
-
-  std::string name() const override {
-    return "envoy.resource_monitors.testonly.fake_resource_monitor";
-  }
-
-  void onMonitorDestroyed(FakeResourceMonitor* monitor);
-
-private:
-  FakeResourceMonitor* monitor_{nullptr};
-};
-
-FakeResourceMonitor::~FakeResourceMonitor() { factory_.onMonitorDestroyed(this); }
-
-void FakeResourceMonitor::updateResourceUsage(Callbacks& callbacks) {
-  Server::ResourceUsage usage;
-  usage.resource_pressure_ = pressure_;
-  callbacks.onSuccess(usage);
-}
-
-void FakeResourceMonitorFactory::onMonitorDestroyed(FakeResourceMonitor* monitor) {
-  ASSERT(monitor_ == monitor);
-  monitor_ = nullptr;
-}
-
-Server::ResourceMonitorPtr FakeResourceMonitorFactory::createResourceMonitor(
-    const Protobuf::Message&, Server::Configuration::ResourceMonitorFactoryContext& context) {
-  auto monitor = std::make_unique<FakeResourceMonitor>(context.dispatcher(), *this);
-  monitor_ = monitor.get();
-  return monitor;
-}
-
-class OverloadIntegrationTest : public HttpProtocolIntegrationTest {
+class OverloadIntegrationTest : public BaseOverloadIntegrationTest,
+                                public HttpProtocolIntegrationTest {
 protected:
   void
   initializeOverloadManager(const envoy::config::overload::v3::OverloadAction& overload_action) {
-    const std::string overload_config = R"EOF(
-        refresh_interval:
-          seconds: 0
-          nanos: 1000000
-        resource_monitors:
-          - name: "envoy.resource_monitors.testonly.fake_resource_monitor"
-            typed_config:
-              "@type": type.googleapis.com/google.protobuf.Empty
-      )EOF";
-    envoy::config::overload::v3::OverloadManager overload_manager_config =
-        TestUtility::parseYaml<envoy::config::overload::v3::OverloadManager>(overload_config);
-    *overload_manager_config.add_actions() = overload_action;
-
-    config_helper_.addConfigModifier(
-        [overload_manager_config](envoy::config::bootstrap::v3::Bootstrap& bootstrap) {
-          *bootstrap.mutable_overload_manager() = overload_manager_config;
-        });
+    setupOverloadManagerConfig(overload_action);
+    config_helper_.addConfigModifier([this](envoy::config::bootstrap::v3::Bootstrap& bootstrap) {
+      *bootstrap.mutable_overload_manager() = this->overload_manager_config_;
+    });
     initialize();
     updateResource(0);
   }
-
-  void updateResource(double pressure) {
-    auto* monitor = fake_resource_monitor_factory_.monitor();
-    ASSERT(monitor != nullptr);
-    monitor->setResourcePressure(pressure);
-  }
-
-  FakeResourceMonitorFactory fake_resource_monitor_factory_;
-  Registry::InjectFactory<Server::Configuration::ResourceMonitorFactory> inject_factory_{
-      fake_resource_monitor_factory_};
 };
 
 INSTANTIATE_TEST_SUITE_P(Protocols, OverloadIntegrationTest,