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:
MockTimer(MockTime * time)19 MockTimer(MockTime* time)
20 : time_(time),
21 running_(false),
22 callback_sequence_number_(0),
23 weak_factory_(this) {
24 DCHECK(time);
25 }
26
~MockTimer()27 virtual ~MockTimer() {}
28
29 // MockableTime::Timer implementation:
Start(const tracked_objects::Location & posted_from,base::TimeDelta delay,const base::Closure & user_task)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
Stop()45 virtual void Stop() OVERRIDE {
46 if (running_) {
47 ++callback_sequence_number_;
48 running_ = false;
49 }
50 }
51
IsRunning()52 virtual bool IsRunning() OVERRIDE { return running_; }
53
54 private:
OnDelayPassed(int expected_callback_sequence_number)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
TestCallback()77 TestCallback::TestCallback()
78 : callback_(base::Bind(&TestCallback::OnCalled,
79 base::Unretained(this))),
80 called_(false) {}
81
~TestCallback()82 TestCallback::~TestCallback() {}
83
OnCalled()84 void TestCallback::OnCalled() {
85 EXPECT_FALSE(called_);
86 called_ = true;
87 }
88
MockUploader(const UploadRequestCallback & callback)89 MockUploader::MockUploader(const UploadRequestCallback& callback)
90 : callback_(callback) {}
91
~MockUploader()92 MockUploader::~MockUploader() {}
93
UploadReport(const std::string & report_json,const GURL & upload_url,const UploadCallback & callback)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
MockTime()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
~MockTime()108 MockTime::~MockTime() {}
109
Now()110 base::Time MockTime::Now() { return now_; }
NowTicks()111 base::TimeTicks MockTime::NowTicks() { return now_ticks_; }
112
CreateTimer()113 scoped_ptr<MockableTime::Timer> MockTime::CreateTimer() {
114 return scoped_ptr<MockableTime::Timer>(new MockTimer(this));
115 }
116
Advance(base::TimeDelta delta)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
AddTask(base::TimeDelta delay,const base::Closure & task)138 void MockTime::AddTask(base::TimeDelta delay, const base::Closure& task) {
139 tasks_[TaskKey(now_ticks_ + delay, task_sequence_number_++)] = task;
140 }
141
AdvanceToInternal(base::TimeTicks target_ticks)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
MakeTestSchedulerParams()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
MakeTestConfig()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