Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(514)

Side by Side Diff: chrome/browser/chromeos/policy/system_log_uploader_unittest.cc

Issue 1280003004: Added policy to disable/enable a system log upload. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fixed comments. Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
OLDNEW
« no previous file with comments | « chrome/browser/chromeos/policy/system_log_uploader.cc ('k') | chrome/browser/chromeos/settings/device_settings_provider.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698