Home | History | Annotate | Download | only in domain_reliability
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/domain_reliability/test_util.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback.h"
      9 #include "components/domain_reliability/scheduler.h"
     10 #include "net/url_request/url_request_status.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 
     13 namespace domain_reliability {
     14 
     15 namespace {
     16 
     17 class MockTimer : public MockableTime::Timer {
     18  public:
     19   MockTimer(MockTime* time)
     20       : time_(time),
     21         running_(false),
     22         callback_sequence_number_(0),
     23         weak_factory_(this) {
     24     DCHECK(time);
     25   }
     26 
     27   virtual ~MockTimer() {}
     28 
     29   // MockableTime::Timer implementation:
     30   virtual void Start(const tracked_objects::Location& posted_from,
     31                      base::TimeDelta delay,
     32                      const base::Closure& user_task) OVERRIDE {
     33     DCHECK(!user_task.is_null());
     34 
     35     if (running_)
     36       ++callback_sequence_number_;
     37     running_ = true;
     38     user_task_ = user_task;
     39     time_->AddTask(delay,
     40         base::Bind(&MockTimer::OnDelayPassed,
     41                    weak_factory_.GetWeakPtr(),
     42                    callback_sequence_number_));
     43   }
     44 
     45   virtual void Stop() OVERRIDE {
     46     if (running_) {
     47       ++callback_sequence_number_;
     48       running_ = false;
     49     }
     50   }
     51 
     52   virtual bool IsRunning() OVERRIDE { return running_; }
     53 
     54  private:
     55   void OnDelayPassed(int expected_callback_sequence_number) {
     56     if (callback_sequence_number_ != expected_callback_sequence_number)
     57       return;
     58 
     59     DCHECK(running_);
     60     running_ = false;
     61 
     62     // Grab user task in case it re-entrantly starts the timer again.
     63     base::Closure task_to_run = user_task_;
     64     user_task_.Reset();
     65     task_to_run.Run();
     66   }
     67 
     68   MockTime* time_;
     69   bool running_;
     70   int callback_sequence_number_;
     71   base::Closure user_task_;
     72   base::WeakPtrFactory<MockTimer> weak_factory_;
     73 };
     74 
     75 }  // namespace
     76 
     77 TestCallback::TestCallback()
     78     : callback_(base::Bind(&TestCallback::OnCalled,
     79                            base::Unretained(this))),
     80       called_(false) {}
     81 
     82 TestCallback::~TestCallback() {}
     83 
     84 void TestCallback::OnCalled() {
     85   EXPECT_FALSE(called_);
     86   called_ = true;
     87 }
     88 
     89 MockUploader::MockUploader(const UploadRequestCallback& callback)
     90     : callback_(callback) {}
     91 
     92 MockUploader::~MockUploader() {}
     93 
     94 void MockUploader::UploadReport(const std::string& report_json,
     95                                 const GURL& upload_url,
     96                                 const UploadCallback& callback) {
     97   callback_.Run(report_json, upload_url, callback);
     98 }
     99 
    100 MockTime::MockTime()
    101     : now_(base::Time::Now()),
    102       now_ticks_(base::TimeTicks::Now()),
    103       epoch_ticks_(now_ticks_),
    104       task_sequence_number_(0) {
    105   VLOG(1) << "Creating mock time: T=" << elapsed_sec() << "s";
    106 }
    107 
    108 MockTime::~MockTime() {}
    109 
    110 base::Time MockTime::Now() { return now_; }
    111 base::TimeTicks MockTime::NowTicks() { return now_ticks_; }
    112 
    113 scoped_ptr<MockableTime::Timer> MockTime::CreateTimer() {
    114   return scoped_ptr<MockableTime::Timer>(new MockTimer(this));
    115 }
    116 
    117 void MockTime::Advance(base::TimeDelta delta) {
    118   base::TimeTicks target_ticks = now_ticks_ + delta;
    119 
    120   while (!tasks_.empty() && tasks_.begin()->first.time <= target_ticks) {
    121     TaskKey key = tasks_.begin()->first;
    122     base::Closure task = tasks_.begin()->second;
    123     tasks_.erase(tasks_.begin());
    124 
    125     DCHECK(now_ticks_ <= key.time);
    126     DCHECK(key.time <= target_ticks);
    127     AdvanceToInternal(key.time);
    128     VLOG(1) << "Advancing mock time: task at T=" << elapsed_sec() << "s";
    129 
    130     task.Run();
    131   }
    132 
    133   DCHECK(now_ticks_ <= target_ticks);
    134   AdvanceToInternal(target_ticks);
    135   VLOG(1) << "Advanced mock time: T=" << elapsed_sec() << "s";
    136 }
    137 
    138 void MockTime::AddTask(base::TimeDelta delay, const base::Closure& task) {
    139   tasks_[TaskKey(now_ticks_ + delay, task_sequence_number_++)] = task;
    140 }
    141 
    142 void MockTime::AdvanceToInternal(base::TimeTicks target_ticks) {
    143   base::TimeDelta delta = target_ticks - now_ticks_;
    144   now_ += delta;
    145   now_ticks_ += delta;
    146 }
    147 
    148 DomainReliabilityScheduler::Params MakeTestSchedulerParams() {
    149   DomainReliabilityScheduler::Params params;
    150   params.minimum_upload_delay = base::TimeDelta::FromMinutes(1);
    151   params.maximum_upload_delay = base::TimeDelta::FromMinutes(5);
    152   params.upload_retry_interval = base::TimeDelta::FromSeconds(15);
    153   return params;
    154 }
    155 
    156 scoped_ptr<const DomainReliabilityConfig> MakeTestConfig() {
    157   DomainReliabilityConfig* config = new DomainReliabilityConfig();
    158   DomainReliabilityConfig::Resource* resource;
    159 
    160   resource = new DomainReliabilityConfig::Resource();
    161   resource->name = "always_report";
    162   resource->url_patterns.push_back(
    163       new std::string("http://example/always_report"));
    164   resource->success_sample_rate = 1.0;
    165   resource->failure_sample_rate = 1.0;
    166   config->resources.push_back(resource);
    167 
    168   resource = new DomainReliabilityConfig::Resource();
    169   resource->name = "never_report";
    170   resource->url_patterns.push_back(
    171       new std::string("http://example/never_report"));
    172   resource->success_sample_rate = 0.0;
    173   resource->failure_sample_rate = 0.0;
    174   config->resources.push_back(resource);
    175 
    176   DomainReliabilityConfig::Collector* collector;
    177   collector = new DomainReliabilityConfig::Collector();
    178   collector->upload_url = GURL("https://example/upload");
    179   config->collectors.push_back(collector);
    180 
    181   config->version = "1";
    182   config->valid_until = 1234567890.0;
    183   config->domain = "example";
    184 
    185   DCHECK(config->IsValid());
    186 
    187   return scoped_ptr<const DomainReliabilityConfig>(config);
    188 }
    189 
    190 }  // namespace domain_reliability
    191