http: moving tests over to new accessors (envoyproxy#11287)

Risk Level: Low (test only) Testing: tests pass Docs Changes: n/a Release Notes: n/a Signed-off-by: Alyssa Wilk <[email protected]>
hango-io · May 26, 2020 · d8b1d11 · d8b1d11
1 parent b6f7235
commit d8b1d11
Show file tree

Hide file tree

Showing 81 changed files with 615 additions and 718 deletions.
diff --git a/source/common/stats/histogram_impl.cc b/source/common/stats/histogram_impl.cc
@@ -11,8 +11,9 @@ namespace Envoy {
 namespace Stats {
 
 HistogramStatisticsImpl::HistogramStatisticsImpl(const histogram_t* histogram_ptr)
-    : computed_quantiles_(supportedQuantiles().size(), 0.0) {
-  hist_approx_quantile(histogram_ptr, supportedQuantiles().data(), supportedQuantiles().size(),
+    : computed_quantiles_(HistogramStatisticsImpl::supportedQuantiles().size(), 0.0) {
+  hist_approx_quantile(histogram_ptr, supportedQuantiles().data(),
+                       HistogramStatisticsImpl::supportedQuantiles().size(),
                        computed_quantiles_.data());
 
   sample_count_ = hist_sample_count(histogram_ptr);

diff --git a/source/common/stats/histogram_impl.h b/source/common/stats/histogram_impl.h
@@ -33,7 +33,7 @@ class HistogramStatisticsImpl : public HistogramStatistics, NonCopyable {
   // HistogramStatistics
   std::string quantileSummary() const override;
   std::string bucketSummary() const override;
-  const std::vector<double>& supportedQuantiles() const override;
+  const std::vector<double>& supportedQuantiles() const final;
   const std::vector<double>& computedQuantiles() const override { return computed_quantiles_; }
   const std::vector<double>& supportedBuckets() const override;
   const std::vector<uint64_t>& computedBuckets() const override { return computed_buckets_; }

diff --git a/test/common/config/http_subscription_test_harness.h b/test/common/config/http_subscription_test_harness.h
@@ -70,12 +70,11 @@ class HttpSubscriptionTestHarness : public SubscriptionTestHarness {
                                                         Http::AsyncClient::Callbacks& callbacks,
                                                         const Http::AsyncClient::RequestOptions&) {
           http_callbacks_ = &callbacks;
-          EXPECT_EQ("POST", std::string(request->headers().Method()->value().getStringView()));
+          EXPECT_EQ("POST", request->headers().getMethodValue());
           EXPECT_EQ(Http::Headers::get().ContentTypeValues.Json,
-                    std::string(request->headers().ContentType()->value().getStringView()));
-          EXPECT_EQ("eds_cluster", std::string(request->headers().Host()->value().getStringView()));
-          EXPECT_EQ("/v2/discovery:endpoints",
-                    std::string(request->headers().Path()->value().getStringView()));
+                    request->headers().getContentTypeValue());
+          EXPECT_EQ("eds_cluster", request->headers().getHostValue());
+          EXPECT_EQ("/v2/discovery:endpoints", request->headers().getPathValue());
           std::string expected_request = "{";
           if (!version_.empty()) {
             expected_request += "\"version_info\":\"" + version + "\",";
@@ -98,7 +97,7 @@ class HttpSubscriptionTestHarness : public SubscriptionTestHarness {
           expected_request += "}";
           EXPECT_EQ(expected_request, request->bodyAsString());
           EXPECT_EQ(fmt::format_int(expected_request.size()).str(),
-                    std::string(request->headers().ContentLength()->value().getStringView()));
+                    request->headers().getContentLengthValue());
           request_in_progress_ = true;
           return &http_request_;
         }));

diff --git a/test/common/config/subscription_factory_impl_test.cc b/test/common/config/subscription_factory_impl_test.cc
@@ -262,11 +262,9 @@ TEST_F(SubscriptionFactoryTest, HttpSubscription) {
   EXPECT_CALL(cm_.async_client_, send_(_, _, _))
       .WillOnce(Invoke([this](Http::RequestMessagePtr& request, Http::AsyncClient::Callbacks&,
                               const Http::AsyncClient::RequestOptions&) {
-        EXPECT_EQ("POST", std::string(request->headers().Method()->value().getStringView()));
-        EXPECT_EQ("static_cluster",
-                  std::string(request->headers().Host()->value().getStringView()));
-        EXPECT_EQ("/v2/discovery:endpoints",
-                  std::string(request->headers().Path()->value().getStringView()));
+        EXPECT_EQ("POST", request->headers().getMethodValue());
+        EXPECT_EQ("static_cluster", request->headers().getHostValue());
+        EXPECT_EQ("/v2/discovery:endpoints", request->headers().getPathValue());
         return &http_request_;
       }));
   EXPECT_CALL(http_request_, cancel());

diff --git a/test/common/grpc/common_test.cc b/test/common/grpc/common_test.cc
@@ -129,97 +129,97 @@ TEST(GrpcContextTest, ToGrpcTimeout) {
   Http::TestRequestHeaderMapImpl headers;
 
   Common::toGrpcTimeout(std::chrono::milliseconds(0UL), headers);
-  EXPECT_EQ("0m", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("0m", headers.getGrpcTimeoutValue());
 
   Common::toGrpcTimeout(std::chrono::milliseconds(1UL), headers);
-  EXPECT_EQ("1m", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("1m", headers.getGrpcTimeoutValue());
 
   Common::toGrpcTimeout(std::chrono::milliseconds(100000000UL), headers);
-  EXPECT_EQ("100000S", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("100000S", headers.getGrpcTimeoutValue());
 
   Common::toGrpcTimeout(std::chrono::milliseconds(100000000000UL), headers);
-  EXPECT_EQ("1666666M", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("1666666M", headers.getGrpcTimeoutValue());
 
   Common::toGrpcTimeout(std::chrono::milliseconds(9000000000000UL), headers);
-  EXPECT_EQ("2500000H", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("2500000H", headers.getGrpcTimeoutValue());
 
   Common::toGrpcTimeout(std::chrono::milliseconds(360000000000000UL), headers);
-  EXPECT_EQ("99999999H", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("99999999H", headers.getGrpcTimeoutValue());
 
   Common::toGrpcTimeout(std::chrono::milliseconds(UINT64_MAX), headers);
-  EXPECT_EQ("99999999H", headers.GrpcTimeout()->value().getStringView());
+  EXPECT_EQ("99999999H", headers.getGrpcTimeoutValue());
 }
 
 TEST(GrpcContextTest, PrepareHeaders) {
   {
     Http::RequestMessagePtr message =
         Common::prepareHeaders("cluster", "service_name", "method_name", absl::nullopt);
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
   }
   {
     Http::RequestMessagePtr message = Common::prepareHeaders(
         "cluster", "service_name", "method_name", absl::optional<std::chrono::milliseconds>(1));
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
-    EXPECT_EQ("1m", message->headers().GrpcTimeout()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
+    EXPECT_EQ("1m", message->headers().getGrpcTimeoutValue());
   }
   {
     Http::RequestMessagePtr message = Common::prepareHeaders(
         "cluster", "service_name", "method_name", absl::optional<std::chrono::seconds>(1));
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
-    EXPECT_EQ("1000m", message->headers().GrpcTimeout()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
+    EXPECT_EQ("1000m", message->headers().getGrpcTimeoutValue());
   }
   {
     Http::RequestMessagePtr message = Common::prepareHeaders(
         "cluster", "service_name", "method_name", absl::optional<std::chrono::minutes>(1));
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
-    EXPECT_EQ("60000m", message->headers().GrpcTimeout()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
+    EXPECT_EQ("60000m", message->headers().getGrpcTimeoutValue());
   }
   {
     Http::RequestMessagePtr message = Common::prepareHeaders(
         "cluster", "service_name", "method_name", absl::optional<std::chrono::hours>(1));
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
-    EXPECT_EQ("3600000m", message->headers().GrpcTimeout()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
+    EXPECT_EQ("3600000m", message->headers().getGrpcTimeoutValue());
   }
   {
     Http::RequestMessagePtr message = Common::prepareHeaders(
         "cluster", "service_name", "method_name", absl::optional<std::chrono::hours>(100000000));
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
-    EXPECT_EQ("99999999H", message->headers().GrpcTimeout()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
+    EXPECT_EQ("99999999H", message->headers().getGrpcTimeoutValue());
   }
   {
     Http::RequestMessagePtr message =
         Common::prepareHeaders("cluster", "service_name", "method_name",
                                absl::optional<std::chrono::milliseconds>(100000000000));
 
-    EXPECT_EQ("POST", message->headers().Method()->value().getStringView());
-    EXPECT_EQ("/service_name/method_name", message->headers().Path()->value().getStringView());
-    EXPECT_EQ("cluster", message->headers().Host()->value().getStringView());
-    EXPECT_EQ("application/grpc", message->headers().ContentType()->value().getStringView());
-    EXPECT_EQ("1666666M", message->headers().GrpcTimeout()->value().getStringView());
+    EXPECT_EQ("POST", message->headers().getMethodValue());
+    EXPECT_EQ("/service_name/method_name", message->headers().getPathValue());
+    EXPECT_EQ("cluster", message->headers().getHostValue());
+    EXPECT_EQ("application/grpc", message->headers().getContentTypeValue());
+    EXPECT_EQ("1666666M", message->headers().getGrpcTimeoutValue());
   }
 }
 

diff --git a/test/common/http/async_client_impl_test.cc b/test/common/http/async_client_impl_test.cc
@@ -67,7 +67,7 @@ class AsyncClientImplTest : public testing::Test {
                              bool end_stream) {
     EXPECT_CALL(callbacks, onHeaders_(_, end_stream))
         .WillOnce(Invoke([code](ResponseHeaderMap& headers, bool) -> void {
-          EXPECT_EQ(std::to_string(code), headers.Status()->value().getStringView());
+          EXPECT_EQ(std::to_string(code), headers.getStatusValue());
         }));
   }
 

diff --git a/test/common/http/conn_manager_impl_fuzz_test.cc b/test/common/http/conn_manager_impl_fuzz_test.cc
@@ -237,11 +237,10 @@ class FuzzStream {
             headers->setReferenceKey(Headers::get().Method, "GET");
           }
           if (headers->Host() != nullptr &&
-              !HeaderUtility::authorityIsValid(headers->Host()->value().getStringView())) {
+              !HeaderUtility::authorityIsValid(headers->getHostValue())) {
             // Sanitize host header so we don't fail at ASSERTs that verify header sanity checks
             // which should have been performed by the codec.
-            headers->setHost(
-                Fuzz::replaceInvalidHostCharacters(headers->Host()->value().getStringView()));
+            headers->setHost(Fuzz::replaceInvalidHostCharacters(headers->getHostValue()));
           }
           // If sendLocalReply is called:
           ON_CALL(encoder_, encodeHeaders(_, true))