OLD | NEW |
---|---|
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/strings/stringprintf.h" | 5 #include "base/strings/stringprintf.h" |
6 #include "base/test/test_simple_task_runner.h" | 6 #include "base/test/test_simple_task_runner.h" |
7 #include "base/time/time.h" | 7 #include "base/time/time.h" |
8 #include "chrome/browser/chromeos/policy/system_log_uploader.h" | 8 #include "chrome/browser/chromeos/policy/system_log_uploader.h" |
9 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h" | |
10 #include "content/public/test/test_browser_thread_bundle.h" | |
11 #include "content/public/test/test_utils.h" | |
9 #include "net/http/http_request_headers.h" | 12 #include "net/http/http_request_headers.h" |
10 #include "testing/gmock/include/gmock/gmock.h" | 13 #include "testing/gmock/include/gmock/gmock.h" |
11 | 14 |
12 namespace policy { | 15 namespace policy { |
13 | 16 |
14 namespace { | 17 namespace { |
15 | 18 |
16 // The list of tested system log file names. | 19 // The list of tested system log file names. |
17 const char* const kTestSystemLogFileNames[] = {"name1.txt", "name32.txt"}; | 20 const char* const kTestSystemLogFileNames[] = {"name1.txt", "name32.txt"}; |
18 | 21 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
103 // MockSystemLogDelegate - mock class that creates an upload job and runs upload | 106 // MockSystemLogDelegate - mock class that creates an upload job and runs upload |
104 // callback. | 107 // callback. |
105 class MockSystemLogDelegate : public SystemLogUploader::Delegate { | 108 class MockSystemLogDelegate : public SystemLogUploader::Delegate { |
106 public: | 109 public: |
107 MockSystemLogDelegate(bool is_upload_error, | 110 MockSystemLogDelegate(bool is_upload_error, |
108 const SystemLogUploader::SystemLogs& system_logs) | 111 const SystemLogUploader::SystemLogs& system_logs) |
109 : is_upload_error_(is_upload_error), system_logs_(system_logs) {} | 112 : is_upload_error_(is_upload_error), system_logs_(system_logs) {} |
110 ~MockSystemLogDelegate() override {} | 113 ~MockSystemLogDelegate() override {} |
111 | 114 |
112 void LoadSystemLogs(const LogUploadCallback& upload_callback) override { | 115 void LoadSystemLogs(const LogUploadCallback& upload_callback) override { |
116 EXPECT_TRUE(is_upload_allowed_); | |
113 upload_callback.Run( | 117 upload_callback.Run( |
114 make_scoped_ptr(new SystemLogUploader::SystemLogs(system_logs_))); | 118 make_scoped_ptr(new SystemLogUploader::SystemLogs(system_logs_))); |
115 } | 119 } |
116 | 120 |
117 scoped_ptr<UploadJob> CreateUploadJob( | 121 scoped_ptr<UploadJob> CreateUploadJob( |
118 const GURL& url, | 122 const GURL& url, |
119 UploadJob::Delegate* delegate) override { | 123 UploadJob::Delegate* delegate) override { |
120 return make_scoped_ptr(new MockUploadJob(url, delegate, is_upload_error_, | 124 return make_scoped_ptr(new MockUploadJob(url, delegate, is_upload_error_, |
121 system_logs_.size())); | 125 system_logs_.size())); |
122 } | 126 } |
123 | 127 |
128 void set_upload_allowed(bool is_upload_allowed) { | |
129 is_upload_allowed_ = is_upload_allowed; | |
130 } | |
131 | |
124 private: | 132 private: |
133 bool is_upload_allowed_; | |
125 bool is_upload_error_; | 134 bool is_upload_error_; |
126 SystemLogUploader::SystemLogs system_logs_; | 135 SystemLogUploader::SystemLogs system_logs_; |
127 }; | 136 }; |
128 | 137 |
129 } // namespace | 138 } // namespace |
130 | 139 |
131 class SystemLogUploaderTest : public testing::Test { | 140 class SystemLogUploaderTest : public testing::Test { |
132 public: | 141 public: |
133 SystemLogUploaderTest() : task_runner_(new base::TestSimpleTaskRunner()) {} | 142 SystemLogUploaderTest() : task_runner_(new base::TestSimpleTaskRunner()) {} |
134 | 143 |
144 void SetUp() override { | |
145 settings_helper_.ReplaceProvider(chromeos::kLogUploadEnabled); | |
146 } | |
147 | |
148 void TearDown() override { | |
149 settings_helper_.RestoreProvider(); | |
150 content::RunAllBlockingPoolTasksUntilIdle(); | |
151 } | |
152 | |
135 // Given a pending task to upload system logs. | 153 // Given a pending task to upload system logs. |
136 void RunPendingUploadTaskAndCheckNext(const SystemLogUploader& uploader, | 154 void RunPendingUploadTaskAndCheckNext(const SystemLogUploader& uploader, |
137 base::TimeDelta expected_delay) { | 155 base::TimeDelta expected_delay) { |
138 EXPECT_FALSE(task_runner_->GetPendingTasks().empty()); | 156 EXPECT_FALSE(task_runner_->GetPendingTasks().empty()); |
139 task_runner_->RunPendingTasks(); | 157 task_runner_->RunPendingTasks(); |
140 | 158 |
141 // The previous task should have uploaded another log upload task. | 159 // The previous task should have uploaded another log upload task. |
142 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); | 160 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); |
143 | 161 |
144 CheckPendingTaskDelay(uploader, expected_delay); | 162 CheckPendingTaskDelay(uploader, expected_delay); |
145 } | 163 } |
146 | 164 |
147 void CheckPendingTaskDelay(const SystemLogUploader& uploader, | 165 void CheckPendingTaskDelay(const SystemLogUploader& uploader, |
148 base::TimeDelta expected_delay) { | 166 base::TimeDelta expected_delay) { |
149 // The next task should be scheduled sometime between | 167 // The next task should be scheduled sometime between |
150 // |last_upload_attempt| + |expected_delay| and | 168 // |last_upload_attempt| + |expected_delay| and |
151 // |now| + |expected_delay|. | 169 // |now| + |expected_delay|. |
152 base::Time now = base::Time::NowFromSystemTime(); | 170 base::Time now = base::Time::NowFromSystemTime(); |
153 base::Time next_task = now + task_runner_->NextPendingTaskDelay(); | 171 base::Time next_task = now + task_runner_->NextPendingTaskDelay(); |
154 | 172 |
155 EXPECT_LE(next_task, now + expected_delay); | 173 EXPECT_LE(next_task, now + expected_delay); |
156 EXPECT_GE(next_task, uploader.last_upload_attempt() + expected_delay); | 174 EXPECT_GE(next_task, uploader.last_upload_attempt() + expected_delay); |
157 } | 175 } |
158 | 176 |
177 protected: | |
178 content::TestBrowserThreadBundle thread_bundle_; | |
179 chromeos::ScopedCrosSettingsTestHelper settings_helper_; | |
159 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | 180 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; |
160 }; | 181 }; |
161 | 182 |
183 // Turn off system log uploads. | |
184 TEST_F(SystemLogUploaderTest, Basic) { | |
185 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); | |
186 | |
187 scoped_ptr<MockSystemLogDelegate> syslog_delegate( | |
188 new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs())); | |
189 syslog_delegate->set_upload_allowed(false); | |
190 SystemLogUploader uploader(syslog_delegate.Pass(), task_runner_); | |
191 | |
192 settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, false); | |
Andrew T Wilson (Slow)
2015/08/13 15:03:20
Remove this line to make sure we default to false.
| |
193 | |
194 task_runner_->RunPendingTasks(); | |
195 } | |
196 | |
162 // One success task pending. | 197 // One success task pending. |
163 TEST_F(SystemLogUploaderTest, SuccessTest) { | 198 TEST_F(SystemLogUploaderTest, SuccessTest) { |
164 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); | 199 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
165 | 200 |
166 SystemLogUploader uploader(make_scoped_ptr(new MockSystemLogDelegate( | 201 scoped_ptr<MockSystemLogDelegate> syslog_delegate( |
167 false, SystemLogUploader::SystemLogs())), | 202 new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs())); |
168 task_runner_); | 203 syslog_delegate->set_upload_allowed(true); |
204 SystemLogUploader uploader(syslog_delegate.Pass(), task_runner_); | |
205 | |
206 settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true); | |
169 | 207 |
170 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); | 208 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); |
171 | 209 |
172 RunPendingUploadTaskAndCheckNext( | 210 RunPendingUploadTaskAndCheckNext( |
173 uploader, base::TimeDelta::FromMilliseconds( | 211 uploader, base::TimeDelta::FromMilliseconds( |
174 SystemLogUploader::kDefaultUploadDelayMs)); | 212 SystemLogUploader::kDefaultUploadDelayMs)); |
175 } | 213 } |
176 | 214 |
177 // Three failed responses recieved. | 215 // Three failed responses recieved. |
178 TEST_F(SystemLogUploaderTest, ThreeFailureTest) { | 216 TEST_F(SystemLogUploaderTest, ThreeFailureTest) { |
179 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); | 217 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
180 | 218 |
181 SystemLogUploader uploader(make_scoped_ptr(new MockSystemLogDelegate( | 219 scoped_ptr<MockSystemLogDelegate> syslog_delegate( |
182 true, SystemLogUploader::SystemLogs())), | 220 new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs())); |
183 task_runner_); | 221 syslog_delegate->set_upload_allowed(true); |
222 SystemLogUploader uploader(syslog_delegate.Pass(), task_runner_); | |
184 | 223 |
224 settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true); | |
185 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); | 225 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); |
186 | 226 |
187 // Do not retry two times consequentially. | 227 // Do not retry two times consequentially. |
188 RunPendingUploadTaskAndCheckNext(uploader, | 228 RunPendingUploadTaskAndCheckNext(uploader, |
189 base::TimeDelta::FromMilliseconds( | 229 base::TimeDelta::FromMilliseconds( |
190 SystemLogUploader::kErrorUploadDelayMs)); | 230 SystemLogUploader::kErrorUploadDelayMs)); |
191 // We are using the kDefaultUploadDelayMs and not the kErrorUploadDelayMs here | 231 // We are using the kDefaultUploadDelayMs and not the kErrorUploadDelayMs here |
192 // because there's just one retry. | 232 // because there's just one retry. |
193 RunPendingUploadTaskAndCheckNext( | 233 RunPendingUploadTaskAndCheckNext( |
194 uploader, base::TimeDelta::FromMilliseconds( | 234 uploader, base::TimeDelta::FromMilliseconds( |
195 SystemLogUploader::kDefaultUploadDelayMs)); | 235 SystemLogUploader::kDefaultUploadDelayMs)); |
196 RunPendingUploadTaskAndCheckNext(uploader, | 236 RunPendingUploadTaskAndCheckNext(uploader, |
197 base::TimeDelta::FromMilliseconds( | 237 base::TimeDelta::FromMilliseconds( |
198 SystemLogUploader::kErrorUploadDelayMs)); | 238 SystemLogUploader::kErrorUploadDelayMs)); |
199 } | 239 } |
200 | 240 |
201 // Check header fields of system log files to upload. | 241 // Check header fields of system log files to upload. |
202 TEST_F(SystemLogUploaderTest, CheckHeaders) { | 242 TEST_F(SystemLogUploaderTest, CheckHeaders) { |
203 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); | 243 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
204 | 244 |
205 SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles(); | 245 SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles(); |
206 SystemLogUploader uploader( | 246 scoped_ptr<MockSystemLogDelegate> syslog_delegate( |
207 make_scoped_ptr(new MockSystemLogDelegate(false, system_logs)), | 247 new MockSystemLogDelegate(false, system_logs)); |
208 task_runner_); | 248 syslog_delegate->set_upload_allowed(true); |
249 SystemLogUploader uploader(syslog_delegate.Pass(), task_runner_); | |
250 | |
251 settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true); | |
209 | 252 |
210 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); | 253 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); |
211 | 254 |
212 RunPendingUploadTaskAndCheckNext( | 255 RunPendingUploadTaskAndCheckNext( |
213 uploader, base::TimeDelta::FromMilliseconds( | 256 uploader, base::TimeDelta::FromMilliseconds( |
214 SystemLogUploader::kDefaultUploadDelayMs)); | 257 SystemLogUploader::kDefaultUploadDelayMs)); |
215 } | 258 } |
216 | 259 |
260 // Disable system log uploads after one failed log upload. | |
261 TEST_F(SystemLogUploaderTest, DisableLogUpload) { | |
262 EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); | |
263 | |
264 scoped_ptr<MockSystemLogDelegate> syslog_delegate( | |
265 new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs())); | |
266 MockSystemLogDelegate* mock_delegate = syslog_delegate.get(); | |
267 SystemLogUploader uploader(syslog_delegate.Pass(), task_runner_); | |
268 | |
269 settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true); | |
270 mock_delegate->set_upload_allowed(true); | |
271 | |
272 EXPECT_EQ(1U, task_runner_->GetPendingTasks().size()); | |
273 RunPendingUploadTaskAndCheckNext(uploader, | |
274 base::TimeDelta::FromMilliseconds( | |
275 SystemLogUploader::kErrorUploadDelayMs)); | |
276 | |
277 // Disable log upload and check that frequency is usual, because there is no | |
278 // errors, we should not upload logs. | |
279 settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, false); | |
280 mock_delegate->set_upload_allowed(false); | |
281 task_runner_->RunPendingTasks(); | |
282 | |
283 RunPendingUploadTaskAndCheckNext( | |
284 uploader, base::TimeDelta::FromMilliseconds( | |
285 SystemLogUploader::kDefaultUploadDelayMs)); | |
286 RunPendingUploadTaskAndCheckNext( | |
287 uploader, base::TimeDelta::FromMilliseconds( | |
288 SystemLogUploader::kDefaultUploadDelayMs)); | |
289 } | |
290 | |
217 } // namespace policy | 291 } // namespace policy |
OLD | NEW |