Add client for background testing of HTTP pipelining.

chrome/browser/net/http_pipelining_compatibility_client_unittest.cc

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/message_loop.h"
+#include "base/metrics/histogram.h"
+#include "base/stl_util.h"
+#include "chrome/browser/net/http_pipelining_compatibility_client.h"
+#include "chrome/test/base/test_url_request_context_getter.h"
+#include "content/test/test_browser_thread.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/test/test_server.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chrome_browser_net {
+
+namespace {
+
+static const char* kHistogramNames[] = {
+  "NetConnectivity.Pipeline.0.NetworkError",
+  "NetConnectivity.Pipeline.0.ResponseCode",
+  "NetConnectivity.Pipeline.0.Status",
+  "NetConnectivity.Pipeline.1.NetworkError",
+  "NetConnectivity.Pipeline.1.ResponseCode",
+  "NetConnectivity.Pipeline.1.Status",
+  "NetConnectivity.Pipeline.2.NetworkError",
+  "NetConnectivity.Pipeline.2.ResponseCode",
+  "NetConnectivity.Pipeline.2.Status",
+};
+
+class HttpPipeliningCompatibilityClientTest : public testing::Test {
+ public:
+  HttpPipeliningCompatibilityClientTest()
+      : test_server_(
+          net::TestServer::TYPE_HTTP,
+          FilePath(FILE_PATH_LITERAL("chrome/test/data/http_pipelining"))) {
+  }
+
+ protected:
+  virtual void SetUp() {
+    ASSERT_TRUE(test_server_.Start());
+    context_ = new TestURLRequestContextGetter;
+    context_->AddRef();
+
+    for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
+      const char* name = kHistogramNames[i];
+      base::Histogram::SampleSet sample = GetHistogram(name);
+      if (sample.TotalCount() > 0) {

[mmenke, 2012/02/01 19:08:07]

If you removed this check, you could also remove the ContainsKey check below,
making things a little simpler.

[James Simonsen, 2012/02/07 00:01:37]

It CHECK fails. Basically, before we've executed any tests, it doesn't know the
size of the ENUM histograms and there's a CHECK that those match during
Subtract(). It's probably not worth taking that out for this (hopefully)
short-lived test.

+        original_histograms_[name] = sample;
+      }
+    }
+  }
+
+  virtual void TearDown() {
+    content::BrowserThread::ReleaseSoon(content::BrowserThread::IO,
+                                        FROM_HERE, context_);
+    message_loop_.RunAllPending();
+  }
+
+  void RunTest(
+      std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests) {
+    HttpPipeliningCompatibilityClient client;
+    net::TestCompletionCallback callback;
+    client.Start(test_server_.GetURL("").spec(),
+    //client.Start("http://127.0.0.1:7777/",

[mmenke, 2012/02/01 19:08:07]

Remove this.

[James Simonsen, 2012/02/07 00:01:37]

Done.

+                 requests, callback.callback(),
+                 context_->GetURLRequestContext());
+    callback.WaitForResult();
+
+    for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
+      const char* name = kHistogramNames[i];
+      base::Histogram::SampleSet sample = GetHistogram(name);
+      if (ContainsKey(original_histograms_, name)) {
+        sample.Subtract(original_histograms_[name]);
+      }
+      histograms_[name] = sample;
+    }
+  }
+
+ private:
+  base::Histogram::SampleSet GetHistogram(const char* name) {
+    base::Histogram::SampleSet sample;
+    base::Histogram* histogram;
+    if (base::StatisticsRecorder::FindHistogram(name, &histogram)) {
+      histogram->SnapshotSample(&sample);
+    }
+    return sample;
+  }
+
+ protected:
+  MessageLoopForIO message_loop_;
+  net::TestServer test_server_;
+  TestURLRequestContextGetter* context_;
+  std::map<std::string, base::Histogram::SampleSet> histograms_;
+
+ private:
+  std::map<std::string, base::Histogram::SampleSet> original_histograms_;
+};
+
+TEST_F(HttpPipeliningCompatibilityClientTest, Success) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "files/alphabet.txt";
+  info.expected_response = "abcdefghijklmnopqrstuvwxyz";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];

[mmenke, 2012/02/01 19:08:07]

Not a big fan of repeating these strings everywhere.  Seems like too much chance
for a typo.

A couple ways to do this.  You add a "GeHistogramValue" function that mimics
GetMetricName from the client, and EXPECT its description is one of the 3
allowed.  Or you skip the expect, and use constants instead, either defined in
this file or the client file.

Or could just make all 9 of them consts.

Or ditch the maps and go with arrays and enums.

[James Simonsen, 2012/02/07 00:01:37]

Done.

+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::SUCCESS));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample.TotalCount());
+  EXPECT_EQ(1, response_sample.counts(200));
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, TooSmall) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "files/alphabet.txt";
+  info.expected_response = "abcdefghijklmnopqrstuvwxyz26";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::TOO_SMALL));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample.TotalCount());
+  EXPECT_EQ(1, response_sample.counts(200));
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, TooLarge) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "files/alphabet.txt";
+  info.expected_response = "abc";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::TOO_LARGE));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample.TotalCount());
+  EXPECT_EQ(1, response_sample.counts(200));
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, Mismatch) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "files/alphabet.txt";
+  info.expected_response = "zyxwvutsrqponmlkjihgfedcba";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::CONTENT_MISMATCH));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample.TotalCount());
+  EXPECT_EQ(1, response_sample.counts(200));
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, Redirect) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "server-redirect?http://foo.bar/asdf";
+  info.expected_response = "shouldn't matter";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::REDIRECTED));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(0, response_sample.TotalCount());
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, AuthRequired) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "auth-basic";
+  info.expected_response = "shouldn't matter";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::BAD_RESPONSE_CODE));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample.TotalCount());
+  EXPECT_EQ(1, response_sample.counts(401));
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, NoContent) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "nocontent";
+  info.expected_response = "shouldn't matter";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::BAD_RESPONSE_CODE));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample.TotalCount());
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample.TotalCount());
+  EXPECT_EQ(1, response_sample.counts(204));
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, CloseSocket) {
+  HttpPipeliningCompatibilityClient::RequestInfo info;
+  info.filename = "close-socket";
+  info.expected_response = "shouldn't matter";
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+  requests.push_back(info);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample.TotalCount());
+  EXPECT_EQ(1, status_sample.counts(
+      HttpPipeliningCompatibilityClient::NETWORK_ERROR));
+
+  base::Histogram::SampleSet network_sample =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(1, network_sample.TotalCount());
+  EXPECT_EQ(1, network_sample.counts(-net::ERR_EMPTY_RESPONSE));
+
+  base::Histogram::SampleSet response_sample =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(0, response_sample.TotalCount());
+}
+
+TEST_F(HttpPipeliningCompatibilityClientTest, MultipleRequests) {
+  std::vector<HttpPipeliningCompatibilityClient::RequestInfo> requests;
+
+  HttpPipeliningCompatibilityClient::RequestInfo info1;
+  info1.filename = "files/alphabet.txt";
+  info1.expected_response = "abcdefghijklmnopqrstuvwxyz";
+  requests.push_back(info1);
+
+  HttpPipeliningCompatibilityClient::RequestInfo info2;
+  info2.filename = "close-socket";
+  info2.expected_response = "shouldn't matter";
+  requests.push_back(info2);
+
+  HttpPipeliningCompatibilityClient::RequestInfo info3;
+  info3.filename = "auth-basic";
+  info3.expected_response = "shouldn't matter";
+  requests.push_back(info3);
+
+  RunTest(requests);
+
+  base::Histogram::SampleSet status_sample1 =
+      histograms_["NetConnectivity.Pipeline.0.Status"];
+  EXPECT_EQ(1, status_sample1.TotalCount());
+  EXPECT_EQ(1, status_sample1.counts(
+      HttpPipeliningCompatibilityClient::SUCCESS));
+
+  base::Histogram::SampleSet network_sample1 =
+      histograms_["NetConnectivity.Pipeline.0.NetworkError"];
+  EXPECT_EQ(0, network_sample1.TotalCount());
+
+  base::Histogram::SampleSet response_sample1 =
+      histograms_["NetConnectivity.Pipeline.0.ResponseCode"];
+  EXPECT_EQ(1, response_sample1.TotalCount());
+  EXPECT_EQ(1, response_sample1.counts(200));
+
+  base::Histogram::SampleSet status_sample2 =
+      histograms_["NetConnectivity.Pipeline.1.Status"];
+  EXPECT_EQ(1, status_sample2.TotalCount());
+  EXPECT_EQ(1, status_sample2.counts(
+      HttpPipeliningCompatibilityClient::NETWORK_ERROR));
+
+  base::Histogram::SampleSet network_sample2 =
+      histograms_["NetConnectivity.Pipeline.1.NetworkError"];
+  EXPECT_EQ(1, network_sample2.TotalCount());
+  EXPECT_EQ(1, network_sample2.counts(-net::ERR_EMPTY_RESPONSE));
+
+  base::Histogram::SampleSet response_sample2 =
+      histograms_["NetConnectivity.Pipeline.1.ResponseCode"];
+  EXPECT_EQ(0, response_sample2.TotalCount());
+
+  base::Histogram::SampleSet status_sample3 =
+      histograms_["NetConnectivity.Pipeline.2.Status"];
+  EXPECT_EQ(1, status_sample3.TotalCount());
+  EXPECT_EQ(1, status_sample3.counts(
+      HttpPipeliningCompatibilityClient::BAD_RESPONSE_CODE));
+
+  base::Histogram::SampleSet network_sample3 =
+      histograms_["NetConnectivity.Pipeline.2.NetworkError"];
+  EXPECT_EQ(0, network_sample3.TotalCount());
+
+  base::Histogram::SampleSet response_sample3 =
+      histograms_["NetConnectivity.Pipeline.2.ResponseCode"];
+  EXPECT_EQ(1, response_sample3.TotalCount());
+  EXPECT_EQ(1, response_sample3.counts(401));
+}
+
+} // anonymous namespace

[mmenke, 2012/02/01 19:08:07]

nit:  2 spaces before comment.

[James Simonsen, 2012/02/07 00:01:37]

Done.

+
+}  // namespace chrome_browser_net