Add net::CertificateReportSender for handling cert report sending

net/url_request/certificate_report_sender_unittest.cc

+// Copyright 2015 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 "net/url_request/certificate_report_sender.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "base/thread_task_runner_handle.h"
+#include "net/base/load_flags.h"
+#include "net/base/network_delegate_impl.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
+#include "net/base/upload_element_reader.h"
+#include "net/test/url_request/url_request_failed_job.h"
+#include "net/test/url_request/url_request_mock_data_job.h"
+#include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+

[davidben, 2015/07/24 18:54:12]

namespace {

[estark, 2015/07/24 22:56:04]

Done (made the whole thing anonymous).

+const char kDummyReport[] = "foo.test";
+const char kSecondDummyReport[] = "foo2.test";
+
+void MarkURLRequestDestroyed(bool* url_request_destroyed) {
+  *url_request_destroyed = true;
+}
+
+void SetUrlRequestMocksEnabled(bool enable) {
+  URLRequestFilter::GetInstance()->ClearHandlers();
+  if (!enable)
+    return;
+
+  URLRequestFailedJob::AddUrlHandler();
+  URLRequestMockDataJob::AddUrlHandler();
+}
+
+// Check that data uploaded in the request matches the test report
+// data. The sent reports will be erased from |expect_reports|.
+void CheckUploadData(URLRequest* request,
+                     std::set<std::string>* expect_reports) {
+  const UploadDataStream* upload = request->get_upload();
+  ASSERT_TRUE(upload);
+  ASSERT_TRUE(upload->GetElementReaders());
+  ASSERT_EQ(1u, upload->GetElementReaders()->size());
+
+  const UploadBytesElementReader* reader =
+      (*upload->GetElementReaders())[0]->AsBytesReader();
+  ASSERT_TRUE(reader);
+  std::string upload_data(reader->bytes(), reader->length());
+
+  EXPECT_EQ(1u, expect_reports->erase(upload_data));
+}
+
+// A network delegate that lets tests check that a certificate report
+// was sent. It counts the number of requests and lets tests register a
+// callback to run when the request is destroyed. It also checks that
+// the uploaded data is as expected.
+class TestCertificateReportSenderNetworkDelegate : public NetworkDelegateImpl {
+ public:
+  TestCertificateReportSenderNetworkDelegate()
+      : url_request_destroyed_callback_(base::Bind(&base::DoNothing)),
+        all_url_requests_destroyed_callback_(base::Bind(&base::DoNothing)),
+        num_requests_(0),
+        expect_cookies_(false) {}
+
+  ~TestCertificateReportSenderNetworkDelegate() override {}
+
+  void ExpectReport(const std::string& report) {
+    expect_reports_.insert(report);
+  }
+
+  void set_all_url_requests_destroyed_callback(
+      const base::Closure& all_url_requests_destroyed_callback) {
+    all_url_requests_destroyed_callback_ = all_url_requests_destroyed_callback;
+  }
+
+  void set_url_request_destroyed_callback(
+      const base::Closure& url_request_destroyed_callback) {
+    url_request_destroyed_callback_ = url_request_destroyed_callback;
+  }
+
+  void set_expect_url(const GURL& expect_url) { expect_url_ = expect_url; }
+
+  size_t num_requests() const { return num_requests_; }
+
+  // Sets whether cookies are expected to be sent on requests.
+  void set_expect_cookies(bool expect_cookies) {
+    expect_cookies_ = expect_cookies;
+  }
+
+  // NetworkDelegateImpl implementation
+  int OnBeforeURLRequest(URLRequest* request,
+                         const CompletionCallback& callback,
+                         GURL* new_url) override {
+    num_requests_++;
+    EXPECT_EQ(expect_url_, request->url());
+    EXPECT_STRCASEEQ("POST", request->method().data());
+
+    if (expect_cookies_) {
+      EXPECT_FALSE(request->load_flags() & LOAD_DO_NOT_SEND_COOKIES);
+      EXPECT_FALSE(request->load_flags() & LOAD_DO_NOT_SAVE_COOKIES);
+    } else {
+      EXPECT_TRUE(request->load_flags() & LOAD_DO_NOT_SEND_COOKIES);
+      EXPECT_TRUE(request->load_flags() & LOAD_DO_NOT_SAVE_COOKIES);
+    }
+
+    CheckUploadData(request, &expect_reports_);
+    return OK;
+  }
+
+  void OnURLRequestDestroyed(URLRequest* request) override {
+    url_request_destroyed_callback_.Run();
+    if (expect_reports_.empty())
+      all_url_requests_destroyed_callback_.Run();
+  }
+
+ private:
+  base::Closure url_request_destroyed_callback_;
+  base::Closure all_url_requests_destroyed_callback_;
+  size_t num_requests_;
+  GURL expect_url_;
+  std::set<std::string> expect_reports_;
+  bool expect_cookies_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCertificateReportSenderNetworkDelegate);
+};

[davidben, 2015/07/24 18:54:12]

}  // namespace

[davidben, 2015/07/24 19:09:08]

Fascinating. Okay, apparently we're way less consistent about this than I
thought we were. mmenke just gave me a totally different recommendation than I
remember whoever-it-was told me last time. (His recommendation was to anonymous
namespace everything.)

So certainly the stuff in here should be anonymous. And we seem to pretty
consistently wrap the file in net.

I retract having an opinion on whether fixtures and tests should be anonymous.
Sorry about the flip-flopping there.

(If fixtures are anonymous, you can't friend them. Whether that's a good thing
or a bad thing is left to the reader's interpretation. Fixture and test names
are global, so that's an argument for exporting them. But that would also be an
argument for not namespacing them, and we namespace net them. But net_unittests
is all in the net namespace. Wrapping the whole thing in anonymous makes it less
of a pain to put random helper functions in places.

Yeah, it's all silly. Yay C++. Too many ways to do everything.)

[estark, 2015/07/24 22:56:03]

Done.

+
+class CertificateReportSenderTest : public ::testing::Test {
+ public:
+  CertificateReportSenderTest() : context_(true) {
+    SetUrlRequestMocksEnabled(true);
+    context_.set_network_delegate(&network_delegate_);
+    context_.Init();
+  }
+
+  ~CertificateReportSenderTest() override { SetUrlRequestMocksEnabled(false); }
+
+  TestCertificateReportSenderNetworkDelegate* network_delegate() {
+    return &network_delegate_;
+  }
+
+  TestURLRequestContext* context() { return &context_; }
+
+ protected:
+  void SendReport(CertificateReportSender* reporter,
+                  const std::string& report,
+                  const GURL& url,
+                  size_t request_sequence_number) {
+    base::RunLoop run_loop;
+    network_delegate_.set_url_request_destroyed_callback(
+        run_loop.QuitClosure());
+
+    network_delegate_.set_expect_url(url);
+    network_delegate_.ExpectReport(report);
+
+    EXPECT_EQ(request_sequence_number, network_delegate_.num_requests());
+
+    reporter->Send(url, report);
+
+    // The report is sent asynchronously, so wait for the report's
+    // URLRequest to be destroyed before checking that the report was
+    // sent.
+    run_loop.Run();
+
+    EXPECT_EQ(request_sequence_number + 1, network_delegate_.num_requests());
+  }
+
+ private:
+  TestCertificateReportSenderNetworkDelegate network_delegate_;
+  TestURLRequestContext context_;
+};
+
+// Test that CertificateReportSender::Send creates a URLRequest for the
+// endpoint and sends the expected data.
+TEST_F(CertificateReportSenderTest, SendsRequest) {
+  GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
+  CertificateReportSender reporter(
+      context(), CertificateReportSender::DO_NOT_SEND_COOKIES);
+  SendReport(&reporter, kDummyReport, url, 0);
+}
+
+TEST_F(CertificateReportSenderTest, SendMultipleReportsSequentially) {
+  GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
+  CertificateReportSender reporter(
+      context(), CertificateReportSender::DO_NOT_SEND_COOKIES);
+  SendReport(&reporter, kDummyReport, url, 0);
+  SendReport(&reporter, kDummyReport, url, 1);
+}
+
+TEST_F(CertificateReportSenderTest, SendMultipleReportsSimultaneously) {
+  base::RunLoop run_loop;
+  network_delegate()->set_all_url_requests_destroyed_callback(
+      run_loop.QuitClosure());
+
+  GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
+  network_delegate()->set_expect_url(url);
+  network_delegate()->ExpectReport(kDummyReport);
+  network_delegate()->ExpectReport(kSecondDummyReport);
+
+  CertificateReportSender reporter(
+      context(), CertificateReportSender::DO_NOT_SEND_COOKIES);
+
+  EXPECT_EQ(0u, network_delegate()->num_requests());
+
+  reporter.Send(url, kDummyReport);
+  reporter.Send(url, kSecondDummyReport);
+
+  run_loop.Run();
+
+  EXPECT_EQ(2u, network_delegate()->num_requests());
+}
+
+// Test that pending URLRequests get cleaned up when the report sender
+// is deleted.
+TEST_F(CertificateReportSenderTest, PendingRequestGetsDeleted) {
+  bool url_request_destroyed = false;
+  network_delegate()->set_url_request_destroyed_callback(base::Bind(
+      &MarkURLRequestDestroyed, base::Unretained(&url_request_destroyed)));
+
+  GURL url = URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
+      URLRequestFailedJob::START, ERR_IO_PENDING);
+  network_delegate()->set_expect_url(url);
+  network_delegate()->ExpectReport(kDummyReport);
+
+  EXPECT_EQ(0u, network_delegate()->num_requests());
+
+  scoped_ptr<CertificateReportSender> reporter(new CertificateReportSender(
+      context(), CertificateReportSender::DO_NOT_SEND_COOKIES));
+  reporter->Send(url, kDummyReport);
+  reporter.reset();
+
+  EXPECT_EQ(1u, network_delegate()->num_requests());
+  EXPECT_TRUE(url_request_destroyed);
+}
+
+// Test that a request that returns an error gets cleaned up.
+TEST_F(CertificateReportSenderTest, ErroredRequestGetsDeleted) {
+  GURL url = URLRequestFailedJob::GetMockHttpsUrl(ERR_FAILED);
+  CertificateReportSender reporter(
+      context(), CertificateReportSender::DO_NOT_SEND_COOKIES);
+  // SendReport will block until the URLRequest is destroyed.
+  SendReport(&reporter, kDummyReport, url, 0);
+}
+
+// Test that cookies are sent or not sent according to the error
+// reporter's cookies preference.
+
+TEST_F(CertificateReportSenderTest, SendCookiesPreference) {
+  GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
+  CertificateReportSender reporter(context(),
+                                   CertificateReportSender::SEND_COOKIES);
+
+  network_delegate()->set_expect_cookies(true);
+  SendReport(&reporter, kDummyReport, url, 0);
+}
+
+TEST_F(CertificateReportSenderTest, DoNotSendCookiesPreference) {
+  GURL url = URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
+  CertificateReportSender reporter(
+      context(), CertificateReportSender::DO_NOT_SEND_COOKIES);
+
+  network_delegate()->set_expect_cookies(false);
+  SendReport(&reporter, kDummyReport, url, 0);
+}
+
+}  // namespace net