upstream: Inline multiplexed_upstream_integration_test.h into multipl…

test/integration/BUILD

@@ -538,7 +538,6 @@ envoy_cc_test(
     name = "multiplexed_upstream_integration_test",
     srcs = [
         "multiplexed_upstream_integration_test.cc",
-        "multiplexed_upstream_integration_test.h",
     ],
     shard_count = 2,
     deps = [

test/integration/multiplexed_upstream_integration_test.cc

@@ -1,5 +1,3 @@
-#include "test/integration/multiplexed_upstream_integration_test.h"
-
 #include <iostream>
 
 #include "envoy/config/bootstrap/v3/bootstrap.pb.h"
@@ -8,62 +6,83 @@
 #include "source/common/http/header_map_impl.h"
 
 #include "test/integration/autonomous_upstream.h"
+#include "test/integration/http_protocol_integration.h"
 #include "test/test_common/printers.h"
 #include "test/test_common/utility.h"
 
 #include "gtest/gtest.h"
 
 namespace Envoy {
 
-INSTANTIATE_TEST_SUITE_P(Protocols, Http2UpstreamIntegrationTest,
+class MultiplexedUpstreamIntegrationTest : public HttpProtocolIntegrationTest {
+public:
+  void initialize() override {
+    upstream_tls_ = true;
+    config_helper_.configureUpstreamTls(use_alpn_, upstreamProtocol() == Http::CodecType::HTTP3);
+    HttpProtocolIntegrationTest::initialize();
+  }
+
+  void bidirectionalStreaming(uint32_t bytes);
+  void manySimultaneousRequests(uint32_t request_bytes, uint32_t max_response_bytes,
+                                uint32_t num_streams = 50);
+
+  bool use_alpn_{false};
+
+  uint64_t upstreamRxResetCounterValue();
+  uint64_t upstreamTxResetCounterValue();
+  uint64_t downstreamRxResetCounterValue();
+  uint64_t downstreamTxResetCounterValue();
+};
+
+INSTANTIATE_TEST_SUITE_P(Protocols, MultiplexedUpstreamIntegrationTest,
                          testing::ValuesIn(HttpProtocolIntegrationTest::getProtocolTestParams(
                              {Http::CodecType::HTTP2},
                              {Http::CodecType::HTTP2, Http::CodecType::HTTP3})),
                          HttpProtocolIntegrationTest::protocolTestParamsToString);
 
-TEST_P(Http2UpstreamIntegrationTest, RouterRequestAndResponseWithBodyNoBuffer) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterRequestAndResponseWithBodyNoBuffer) {
   testRouterRequestAndResponseWithBody(1024, 512, false);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterRequestAndResponseWithZeroByteBodyNoBuffer) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterRequestAndResponseWithZeroByteBodyNoBuffer) {
   testRouterRequestAndResponseWithBody(0, 0, false);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterHeaderOnlyRequestAndResponseNoBuffer) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterHeaderOnlyRequestAndResponseNoBuffer) {
   testRouterHeaderOnlyRequestAndResponse();
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterUpstreamDisconnectBeforeRequestcomplete) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterUpstreamDisconnectBeforeRequestcomplete) {
   testRouterUpstreamDisconnectBeforeRequestComplete();
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterUpstreamDisconnectBeforeResponseComplete) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterUpstreamDisconnectBeforeResponseComplete) {
   testRouterUpstreamDisconnectBeforeResponseComplete();
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterDownstreamDisconnectBeforeRequestComplete) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterDownstreamDisconnectBeforeRequestComplete) {
   testRouterDownstreamDisconnectBeforeRequestComplete();
 
   // Given the downstream disconnect, Envoy will reset the upstream stream.
   EXPECT_EQ(1, upstreamTxResetCounterValue());
   EXPECT_EQ(0, upstreamRxResetCounterValue());
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterDownstreamDisconnectBeforeResponseComplete) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterDownstreamDisconnectBeforeResponseComplete) {
   testRouterDownstreamDisconnectBeforeResponseComplete();
 }
 
-TEST_P(Http2UpstreamIntegrationTest, RouterUpstreamResponseBeforeRequestComplete) {
+TEST_P(MultiplexedUpstreamIntegrationTest, RouterUpstreamResponseBeforeRequestComplete) {
   testRouterUpstreamResponseBeforeRequestComplete();
 }
 
-TEST_P(Http2UpstreamIntegrationTest, Retry) { testRetry(); }
+TEST_P(MultiplexedUpstreamIntegrationTest, Retry) { testRetry(); }
 
-TEST_P(Http2UpstreamIntegrationTest, GrpcRetry) { testGrpcRetry(); }
+TEST_P(MultiplexedUpstreamIntegrationTest, GrpcRetry) { testGrpcRetry(); }
 
-TEST_P(Http2UpstreamIntegrationTest, Trailers) { testTrailers(1024, 2048, true, true); }
+TEST_P(MultiplexedUpstreamIntegrationTest, Trailers) { testTrailers(1024, 2048, true, true); }
 
-TEST_P(Http2UpstreamIntegrationTest, TestSchemeAndXFP) {
+TEST_P(MultiplexedUpstreamIntegrationTest, TestSchemeAndXFP) {
   autonomous_upstream_ = true;
   initialize();
 
@@ -91,7 +110,7 @@ TEST_P(Http2UpstreamIntegrationTest, TestSchemeAndXFP) {
 }
 
 // Ensure Envoy handles streaming requests and responses simultaneously.
-void Http2UpstreamIntegrationTest::bidirectionalStreaming(uint32_t bytes) {
+void MultiplexedUpstreamIntegrationTest::bidirectionalStreaming(uint32_t bytes) {
   initialize();
   codec_client_ = makeHttpConnection(lookupPort("http"));
 
@@ -126,32 +145,32 @@ void Http2UpstreamIntegrationTest::bidirectionalStreaming(uint32_t bytes) {
   EXPECT_TRUE(response->complete());
 }
 
-TEST_P(Http2UpstreamIntegrationTest, BidirectionalStreaming) { bidirectionalStreaming(1024); }
+TEST_P(MultiplexedUpstreamIntegrationTest, BidirectionalStreaming) { bidirectionalStreaming(1024); }
 
-TEST_P(Http2UpstreamIntegrationTest, LargeBidirectionalStreamingWithBufferLimits) {
+TEST_P(MultiplexedUpstreamIntegrationTest, LargeBidirectionalStreamingWithBufferLimits) {
   config_helper_.setBufferLimits(1024, 1024); // Set buffer limits upstream and downstream.
   bidirectionalStreaming(1024 * 32);
 }
 
-uint64_t Http2UpstreamIntegrationTest::upstreamRxResetCounterValue() {
+uint64_t MultiplexedUpstreamIntegrationTest::upstreamRxResetCounterValue() {
   return test_server_
       ->counter(absl::StrCat("cluster.cluster_0.", upstreamProtocolStatsRoot(), ".rx_reset"))
       ->value();
 }
 
-uint64_t Http2UpstreamIntegrationTest::upstreamTxResetCounterValue() {
+uint64_t MultiplexedUpstreamIntegrationTest::upstreamTxResetCounterValue() {
   return test_server_
       ->counter(absl::StrCat("cluster.cluster_0.", upstreamProtocolStatsRoot(), ".tx_reset"))
       ->value();
 }
-uint64_t Http2UpstreamIntegrationTest::downstreamRxResetCounterValue() {
+uint64_t MultiplexedUpstreamIntegrationTest::downstreamRxResetCounterValue() {
   return test_server_->counter(absl::StrCat(downstreamProtocolStatsRoot(), ".rx_reset"))->value();
 }
-uint64_t Http2UpstreamIntegrationTest::downstreamTxResetCounterValue() {
+uint64_t MultiplexedUpstreamIntegrationTest::downstreamTxResetCounterValue() {
   return test_server_->counter(absl::StrCat(downstreamProtocolStatsRoot(), ".tx_reset"))->value();
 }
 
-TEST_P(Http2UpstreamIntegrationTest, BidirectionalStreamingReset) {
+TEST_P(MultiplexedUpstreamIntegrationTest, BidirectionalStreamingReset) {
   initialize();
   codec_client_ = makeHttpConnection(lookupPort("http"));
 
@@ -193,18 +212,18 @@ TEST_P(Http2UpstreamIntegrationTest, BidirectionalStreamingReset) {
   EXPECT_EQ(1, downstreamTxResetCounterValue());
 }
 
-TEST_P(Http2UpstreamIntegrationTest, SimultaneousRequest) {
+TEST_P(MultiplexedUpstreamIntegrationTest, SimultaneousRequest) {
   simultaneousRequest(1024, 512, 1023, 513);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, LargeSimultaneousRequestWithBufferLimits) {
+TEST_P(MultiplexedUpstreamIntegrationTest, LargeSimultaneousRequestWithBufferLimits) {
   config_helper_.setBufferLimits(1024, 1024); // Set buffer limits upstream and downstream.
   simultaneousRequest(1024 * 20, 1024 * 14 + 2, 1024 * 10 + 5, 1024 * 16);
 }
 
-void Http2UpstreamIntegrationTest::manySimultaneousRequests(uint32_t request_bytes,
-                                                            uint32_t max_response_bytes,
-                                                            uint32_t num_requests) {
+void MultiplexedUpstreamIntegrationTest::manySimultaneousRequests(uint32_t request_bytes,
+                                                                  uint32_t max_response_bytes,
+                                                                  uint32_t num_requests) {
   TestRandomGenerator rand;
   std::vector<Http::RequestEncoder*> encoders;
   std::vector<IntegrationStreamDecoderPtr> responses;
@@ -247,15 +266,15 @@ void Http2UpstreamIntegrationTest::manySimultaneousRequests(uint32_t request_byt
   EXPECT_EQ(0, test_server_->gauge("http2.pending_send_bytes")->value());
 }
 
-TEST_P(Http2UpstreamIntegrationTest, ManySimultaneousRequest) {
+TEST_P(MultiplexedUpstreamIntegrationTest, ManySimultaneousRequest) {
   manySimultaneousRequests(1024, 1024, 100);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, TooManySimultaneousRequests) {
+TEST_P(MultiplexedUpstreamIntegrationTest, TooManySimultaneousRequests) {
   manySimultaneousRequests(1024, 1024, 200);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, ManySimultaneousRequestsTightUpstreamLimits) {
+TEST_P(MultiplexedUpstreamIntegrationTest, ManySimultaneousRequestsTightUpstreamLimits) {
   if (upstreamProtocol() == Http::CodecType::HTTP2) {
     return;
   }
@@ -269,12 +288,12 @@ TEST_P(Http2UpstreamIntegrationTest, ManySimultaneousRequestsTightUpstreamLimits
   manySimultaneousRequests(1024, 1024, 10);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, ManyLargeSimultaneousRequestWithBufferLimits) {
+TEST_P(MultiplexedUpstreamIntegrationTest, ManyLargeSimultaneousRequestWithBufferLimits) {
   config_helper_.setBufferLimits(1024, 1024); // Set buffer limits upstream and downstream.
   manySimultaneousRequests(1024 * 20, 1024 * 20);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, ManyLargeSimultaneousRequestWithRandomBackup) {
+TEST_P(MultiplexedUpstreamIntegrationTest, ManyLargeSimultaneousRequestWithRandomBackup) {
   if (upstreamProtocol() == Http::CodecType::HTTP3 &&
       downstreamProtocol() == Http::CodecType::HTTP2) {
     // This test depends on fragile preconditions.
@@ -293,7 +312,7 @@ TEST_P(Http2UpstreamIntegrationTest, ManyLargeSimultaneousRequestWithRandomBacku
   manySimultaneousRequests(1024 * 20, 1024 * 20);
 }
 
-TEST_P(Http2UpstreamIntegrationTest, UpstreamConnectionCloseWithManyStreams) {
+TEST_P(MultiplexedUpstreamIntegrationTest, UpstreamConnectionCloseWithManyStreams) {
   config_helper_.setBufferLimits(1024, 1024); // Set buffer limits upstream and downstream.
   const uint32_t num_requests = 20;
   std::vector<Http::RequestEncoder*> encoders;
@@ -355,7 +374,7 @@ TEST_P(Http2UpstreamIntegrationTest, UpstreamConnectionCloseWithManyStreams) {
 }
 
 // Regression test for https://github.com/envoyproxy/envoy/issues/6744
-TEST_P(Http2UpstreamIntegrationTest, HittingEncoderFilterLimitForGrpc) {
+TEST_P(MultiplexedUpstreamIntegrationTest, HittingEncoderFilterLimitForGrpc) {
   config_helper_.addConfigModifier(
       [&](envoy::extensions::filters::network::http_connection_manager::v3::HttpConnectionManager&
               hcm) -> void {
@@ -423,7 +442,7 @@ name: router
 
 // Tests the default limit for the number of response headers is 100. Results in a stream reset if
 // exceeds.
-TEST_P(Http2UpstreamIntegrationTest, TestManyResponseHeadersRejected) {
+TEST_P(MultiplexedUpstreamIntegrationTest, TestManyResponseHeadersRejected) {
   // Default limit for response headers is 100.
   initialize();
   codec_client_ = makeHttpConnection(lookupPort("http"));
@@ -442,7 +461,7 @@ TEST_P(Http2UpstreamIntegrationTest, TestManyResponseHeadersRejected) {
 }
 
 // Tests bootstrap configuration of max response headers.
-TEST_P(Http2UpstreamIntegrationTest, ManyResponseHeadersAccepted) {
+TEST_P(MultiplexedUpstreamIntegrationTest, ManyResponseHeadersAccepted) {
   // Set max response header count to 200.
   config_helper_.addConfigModifier([](envoy::config::bootstrap::v3::Bootstrap& bootstrap) {
     ConfigHelper::HttpProtocolOptions protocol_options;
@@ -470,7 +489,7 @@ TEST_P(Http2UpstreamIntegrationTest, ManyResponseHeadersAccepted) {
 }
 
 // Tests that HTTP/2 response headers over 60 kB are rejected and result in a stream reset.
-TEST_P(Http2UpstreamIntegrationTest, LargeResponseHeadersRejected) {
+TEST_P(MultiplexedUpstreamIntegrationTest, LargeResponseHeadersRejected) {
   initialize();
   codec_client_ = makeHttpConnection(lookupPort("http"));
 
@@ -488,7 +507,7 @@ TEST_P(Http2UpstreamIntegrationTest, LargeResponseHeadersRejected) {
 // Regression test to make sure that configuring upstream logs over gRPC will not crash Envoy.
 // TODO(asraa): Test output of the upstream logs.
 // See https://github.com/envoyproxy/envoy/issues/8828.
-TEST_P(Http2UpstreamIntegrationTest, ConfigureHttpOverGrpcLogs) {
+TEST_P(MultiplexedUpstreamIntegrationTest, ConfigureHttpOverGrpcLogs) {
   config_helper_.addConfigModifier(
       [&](envoy::extensions::filters::network::http_connection_manager::v3::HttpConnectionManager&
               hcm) -> void {
@@ -529,7 +548,7 @@ name: router
 }
 
 // Regression test for https://github.com/envoyproxy/envoy/issues/13933
-TEST_P(Http2UpstreamIntegrationTest, MultipleRequestsLowStreamLimit) {
+TEST_P(MultiplexedUpstreamIntegrationTest, MultipleRequestsLowStreamLimit) {
   autonomous_upstream_ = true;
   envoy::config::core::v3::Http2ProtocolOptions config;
   config.mutable_max_concurrent_streams()->set_value(1);
@@ -560,7 +579,7 @@ TEST_P(Http2UpstreamIntegrationTest, MultipleRequestsLowStreamLimit) {
 }
 
 // Regression test for https://github.com/envoyproxy/envoy/issues/13933
-TEST_P(Http2UpstreamIntegrationTest, UpstreamGoaway) {
+TEST_P(MultiplexedUpstreamIntegrationTest, UpstreamGoaway) {
   initialize();
   codec_client_ = makeHttpConnection(lookupPort("http"));