Added unittests for SystemLogUploader.

chrome/browser/chromeos/policy/system_log_uploader_unittest.cc

Index: chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
diff --git a/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc b/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a6b02c6952fa892f7f7615906e9aa8cf3e3e01b7
--- /dev/null
+++ b/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
@@ -0,0 +1,164 @@
+// Copyright (c) 2015 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 "base/test/test_simple_task_runner.h"
+#include "base/time/time.h"
+#include "chrome/browser/chromeos/policy/system_log_uploader.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace policy {
+
+// MockSystemLogDelegate - mock class that does nothing.
+class MockSystemLogDelegate : public SystemLogUploadJob::Delegate {
+ public:
+  MockSystemLogDelegate();
+  ~MockSystemLogDelegate() override;
+
+  void LoadSystemLogs(
+      const SystemLogUploadJob::LogUploadCallback& upload_callback) override;
+  scoped_ptr<UploadJob> CreateUploadJob(const GURL&,
+                                        UploadJob::Delegate*) override;
+};
+
+// MockSystemLogUploadJob - mock class that stores the SUCCESS or FAILURE
+// response and invokes appropriate SystemLogUploader's callback.
+class MockSystemLogUploadJob : public SystemLogUploadJob {
+ public:
+  // Store response from server on system log upload.
+  explicit MockSystemLogUploadJob(
+      scoped_ptr<MockSystemLogDelegate> syslog_delegate,
+      bool response);
+  ~MockSystemLogUploadJob() override;
+
+  // Runs succeeded or failed callback according to response_ stored.
+  void Run(const base::Closure& succeeded_callback,
+           const base::Closure& failed_callback) override;
+
+ private:
+  bool response_;
+};
+
+// MockSystemLogUploader - overrides only the creation of the system log
+// upload job of SystemLogUploader.
+class MockSystemLogUploader : public SystemLogUploader {
+ public:
+  MockSystemLogUploader(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+      bool result);
+
+ private:
+  SystemLogUploadJob* CreateSystemLogUploadJob() override;
+  // Passed to the upload job.
+  bool response_;
+};
+
+MockSystemLogUploader::MockSystemLogUploader(
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+    bool response)
+    : SystemLogUploader(task_runner), response_(response) {
+}
+
+SystemLogUploadJob* MockSystemLogUploader::CreateSystemLogUploadJob() {
+  // Passes |response_| to the upload job.
+  return new MockSystemLogUploadJob(
+      make_scoped_ptr(new MockSystemLogDelegate()), response_);
+}
+
+class SystemLogUploaderTest : public testing::Test {
+ public:
+  SystemLogUploaderTest() : task_runner_(new base::TestSimpleTaskRunner()) {}
+
+  // Given a pending task to upload system logs.
+  void RunPendingUploadTaskAndCheckNext(const MockSystemLogUploader& uploader,
+                                        base::TimeDelta expected_delay) {
+    EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+    task_runner_->RunPendingTasks();
+
+    // The previours task scheduled new log upload task.
+    EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+
+    CheckPendingTaskDelay(uploader, expected_delay);
+  }
+
+  void CheckPendingTaskDelay(const MockSystemLogUploader& uploader,
+                             base::TimeDelta expected_delay) {
+    // The next task should be scheduled sometime between
+    // |last_upload_attempt| + |expected_delay| and
+    // |now| + |expected_delay|.
+    base::Time now = base::Time::NowFromSystemTime();
+    base::Time next_task = now + task_runner_->NextPendingTaskDelay();
+
+    EXPECT_LE(next_task, now + expected_delay);
+    EXPECT_GE(next_task, uploader.last_upload_attempt() + expected_delay);
+  }
+
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+};
+
+MockSystemLogDelegate::MockSystemLogDelegate() {
+}
+
+MockSystemLogDelegate::~MockSystemLogDelegate() {
+}
+
+void MockSystemLogDelegate::LoadSystemLogs(
+    const SystemLogUploadJob::LogUploadCallback& upload_callback) {
+}
+
+scoped_ptr<UploadJob> MockSystemLogDelegate::CreateUploadJob(
+    const GURL& upload_url,
+    UploadJob::Delegate* delegate) {
+  return nullptr;
+}
+
+MockSystemLogUploadJob::MockSystemLogUploadJob(
+    scoped_ptr<MockSystemLogDelegate> syslog_delegate,
+    bool response)
+    : SystemLogUploadJob(syslog_delegate.Pass()), response_(response) {
+}
+
+MockSystemLogUploadJob::~MockSystemLogUploadJob() {
+}
+
+void MockSystemLogUploadJob::Run(const base::Closure& succeeded_callback,
+                                 const base::Closure& failed_callback) {
+  if (response_)
+    succeeded_callback.Run();
+  else
+    failed_callback.Run();
+}
+
+// One success task pending.
+TEST_F(SystemLogUploaderTest, SuccessTest) {
+  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+
+  MockSystemLogUploader uploader(task_runner_, true);
+
+  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+
+  CheckPendingTaskDelay(uploader,
+                        base::TimeDelta::FromMilliseconds(
+                            SystemLogUploader::kDefaultUploadDelayMs));
+}
+
+// Three failed responses recieved.
+TEST_F(SystemLogUploaderTest, ThreeFailureTest) {
+  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+  MockSystemLogUploader uploader(task_runner_, false);
+
+  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+
+  // Do not retry two times consequentially.
+  RunPendingUploadTaskAndCheckNext(uploader,
+                                   base::TimeDelta::FromMilliseconds(
+                                       SystemLogUploader::kErrorUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(
+      uploader, base::TimeDelta::FromMilliseconds(
+                    SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(uploader,
+                                   base::TimeDelta::FromMilliseconds(
+                                       SystemLogUploader::kErrorUploadDelayMs));
+}

[Andrew T Wilson (Slow), 2015/07/03 16:20:00]

Good, you've covered the cases of making sure that the right retry times are
used.

Are there other tests we should also include? maybe also check to make sure that
the right headers are being set and the right data is being sent up to the
upload job?

[Polina Bondarenko, 2015/07/10 13:24:22]

I decided to test it separately. Thus here is the unit tests for system log
uploader (checking times and appropriate success/failure callbacks), and the
unittests that check the headers of UploadJob are added to the
system_log_upload_job_unittest.cc file.

+
+}  // namespace policy