blob: 6d19d33593b49f0fae6e574ab0c90322186ba593 [file] [log] [blame]
// Copyright 2016 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 <unordered_map>
#include "base/macros.h"
#include "base/run_loop.h"
#include "base/sequence_checker.h"
#include "base/test/metrics/histogram_tester.h"
#include "chrome/browser/safe_browsing/certificate_reporting_service.h"
#include "content/public/test/test_browser_thread.h"
#include "content/public/test/test_browser_thread_bundle.h"
#include "net/base/network_delegate_impl.h"
#include "net/url_request/url_request_interceptor.h"
#include "net/url_request/url_request_job.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "services/network/public/mojom/url_loader.mojom.h"
namespace net {
class NetworkDelegate;
namespace certificate_reporting_test_utils {
enum RetryStatus {
typedef std::unordered_map<std::string, RetryStatus> ObservedReportMap;
// Syntactic sugar for wrapping report expectations in a more readable way.
// Passed to WaitForRequestDeletions() as input.
// Example:
// The following expects report0 and report1 to be successfully sent and their
// URL requests to be deleted:
// WaitForRequestsDestroyed(
// ReportExpectation::Successful("report0, report1"));
struct ReportExpectation {
ReportExpectation(const ReportExpectation& other);
// Returns an expectation where all reports in |reports| succeed.
static ReportExpectation Successful(const ObservedReportMap& reports);
// Returns an expectation where all reports in |reports| fail.
static ReportExpectation Failed(const ObservedReportMap& reports);
// Returns an expectation where all reports in |reports| are delayed.
static ReportExpectation Delayed(const ObservedReportMap& reports);
// Total number of reports expected.
int num_reports() const;
ObservedReportMap successful_reports;
ObservedReportMap failed_reports;
ObservedReportMap delayed_reports;
// Failure mode of the report sending attempts.
enum ReportSendingResult {
// Report send attempts should be successful.
// Report send attempts should fail.
// Report send attempts should hang until explicitly resumed.
// Helper class to wait for a number of events (e.g. request destroyed, report
// observed).
class RequestObserver {
// Waits for |num_request| requests to be created or destroyed, depending on
// whichever one this class observes.
void Wait(unsigned int num_events_to_wait_for);
// Called when a request created or destroyed, depending on whichever one this
// class observes.
void OnRequest(const std::string& serialized_report,
ReportSendingResult report_type);
// These must be called on the UI thread.
const ObservedReportMap& successful_reports() const;
const ObservedReportMap& failed_reports() const;
const ObservedReportMap& delayed_reports() const;
const std::vector<std::string>& full_reports() const;
void ClearObservedReports();
unsigned int num_events_to_wait_for_;
unsigned int num_received_events_;
std::unique_ptr<base::RunLoop> run_loop_;
ObservedReportMap successful_reports_;
ObservedReportMap failed_reports_;
ObservedReportMap delayed_reports_;
std::vector<std::string> full_reports_;
// A URLRequestJob that can be delayed until Resume() is called. Returns an
// empty response. If Resume() is called before a request is made, then the
// request will not be delayed. If not delayed, it can return a failed or a
// successful URL request job.
class DelayableCertReportURLRequestJob : public net::URLRequestJob {
bool delayed,
bool should_fail,
net::URLRequest* request,
net::NetworkDelegate* network_delegate,
const base::Callback<void()>& destruction_callback);
~DelayableCertReportURLRequestJob() override;
base::WeakPtr<DelayableCertReportURLRequestJob> GetWeakPtr();
// net::URLRequestJob methods:
void Start() override;
int ReadRawData(net::IOBuffer* buf, int buf_size) override;
void GetResponseInfo(net::HttpResponseInfo* info) override;
// Resumes a previously started request that was delayed. If no
// request has been started yet, then when Start() is called it will
// not delay.
void Resume();
bool delayed_;
bool should_fail_;
bool started_;
base::Callback<void()> destruction_callback_;
base::WeakPtrFactory<DelayableCertReportURLRequestJob> weak_factory_;
// Class to wait for the CertificateReportingService to reset.
class CertificateReportingServiceObserver {
// Clears the state of the observer. Must be called before waiting each time.
void Clear();
// Waits for the service to reset.
void WaitForReset();
// Must be called when the service is reset.
void OnServiceReset();
bool did_reset_ = false;
std::unique_ptr<base::RunLoop> run_loop_;
// Base class for CertificateReportingService tests.
class CertificateReportingServiceTestHelper
: public network::SharedURLLoaderFactory {
// Changes the behavior of report uploads to fail, succeed or hang.
void SetFailureMode(ReportSendingResult expected_report_result);
// Resumes delayed report request. Failure mode should be REPORTS_DELAY when
// calling this method.
void ResumeDelayedRequest();
void WaitForRequestsCreated(const ReportExpectation& expectation);
void WaitForRequestsCreated(const ReportExpectation& expectation,
std::vector<std::string>* full_reports);
void WaitForRequestsDestroyed(const ReportExpectation& expectation);
void WaitForRequestsDestroyed(const ReportExpectation& expectation,
std::vector<std::string>* full_reports);
// Checks that all requests are destroyed and that there are no in-flight
// reports in |service|.
void ExpectNoRequests(CertificateReportingService* service);
uint8_t* server_public_key();
uint32_t server_public_key_version() const;
friend class base::RefCounted<CertificateReportingServiceTestHelper>;
~CertificateReportingServiceTestHelper() override;
void SendResponse(network::mojom::URLLoaderClientPtr client, bool fail);
// network::SharedURLLoaderFactory
void CreateLoaderAndStart(network::mojom::URLLoaderRequest request,
int32_t routing_id,
int32_t request_id,
uint32_t options,
const network::ResourceRequest& url_request,
network::mojom::URLLoaderClientPtr client,
const net::MutableNetworkTrafficAnnotationTag&
traffic_annotation) override;
void Clone(network::mojom::URLLoaderFactoryRequest request) override;
std::unique_ptr<network::SharedURLLoaderFactoryInfo> Clone() override;
ReportSendingResult expected_report_result_;
network::mojom::URLLoaderClientPtr delayed_client_;
std::string delayed_report_;
ReportSendingResult delayed_result_;
RequestObserver request_created_observer_;
RequestObserver request_destroyed_observer_;
uint8_t server_public_key_[32];
uint8_t server_private_key_[32];
// Class to test reporting events histogram for CertificateReportingService.
// We can't use a simple HistogramTester, as we need to wait until test teardown
// to check the histogram contents. This ensures that all in-flight requests
// are torn down by the time we check the histograms.
class EventHistogramTester {
void SetExpectedValues(int submitted,
int failed,
int successful,
int dropped);
int submitted_ = 0;
int failed_ = 0;
int successful_ = 0;
int dropped_ = 0;
base::HistogramTester histogram_tester_;
} // namespace certificate_reporting_test_utils