Added unittests for SystemLogUploader.

chrome/browser/chromeos/policy/system_log_upload_job_unittest.cc

+// Copyright 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/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/test_mock_time_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time/time.h"
+#include "chrome/browser/chromeos/policy/system_log_upload_job.h"
+#include "chrome/browser/chromeos/policy/upload_job.h"
+#include "content/public/test/test_browser_thread.h"
+#include "net/http/http_request_headers.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace policy {
+
+namespace {
+
+// The list of tested system log file names.
+const char* const kTestSystemLogFileNames[] = {"my_system_log_file.txt"};
+
+// Number of the system log files to upload in the list.
+const int kMaxNumTestSystemLogFileNames = 1;
+
+class MockUploadJob : public policy::UploadJob {
+ public:
+  // If |error_code| is a null pointer OnSuccess() will be invoked when the
+  // Start() method is called, otherwise OnFailure() will be invoked with the
+  // respective |error_code|.
+  MockUploadJob(const GURL& upload_url,
+                UploadJob::Delegate* delegate,
+                scoped_ptr<UploadJob::ErrorCode> error_code);
+  ~MockUploadJob() override;
+
+  // policy::UploadJob:
+  void AddDataSegment(const std::string& name,
+                      const std::string& filename,
+                      const std::map<std::string, std::string>& header_entries,
+                      scoped_ptr<std::string> data) override;
+  void Start() override;
+
+ protected:
+  UploadJob::Delegate* delegate_;
+  scoped_ptr<UploadJob::ErrorCode> error_code_;
+  int file_index_;
+};
+
+MockUploadJob::MockUploadJob(const GURL& upload_url,
+                             UploadJob::Delegate* delegate,
+                             scoped_ptr<UploadJob::ErrorCode> error_code)
+    : delegate_(delegate), error_code_(error_code.Pass()), file_index_(0) {
+}
+
+MockUploadJob::~MockUploadJob() {
+}
+
+void MockUploadJob::AddDataSegment(
+    const std::string& name,
+    const std::string& filename,
+    const std::map<std::string, std::string>& header_entries,
+    scoped_ptr<std::string> data) {
+  // Test all fields to upload.
+  EXPECT_LT(file_index_, kMaxNumTestSystemLogFileNames);
+  EXPECT_GE(file_index_, 0);
+
+  EXPECT_EQ(base::StringPrintf(SystemLogUploadJob::kNameFieldTemplate,
+                               file_index_ + 1),
+            name);
+
+  EXPECT_EQ(kTestSystemLogFileNames[file_index_], filename);
+
+  EXPECT_EQ(2U, header_entries.size());
+  EXPECT_EQ(
+      SystemLogUploadJob::kFileTypeLogFile,
+      header_entries.find(SystemLogUploadJob::kFileTypeHeaderName)->second);
+  EXPECT_EQ(SystemLogUploadJob::kContentTypePlainText,
+            header_entries.find(net::HttpRequestHeaders::kContentType)->second);
+
+  EXPECT_EQ(kTestSystemLogFileNames[file_index_], *data);
+
+  file_index_++;
+}
+
+void MockUploadJob::Start() {
+  DCHECK(delegate_);
+  if (error_code_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&UploadJob::Delegate::OnFailure,
+                              base::Unretained(delegate_), *error_code_));
+  } else {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&UploadJob::Delegate::OnSuccess,
+                              base::Unretained(delegate_)));
+  }
+}
+
+// Generate the fake system log files.
+scoped_ptr<SystemLogUploadJob::SystemLogs> GenerateTestSystemLogFiles() {
+  scoped_ptr<SystemLogUploadJob::SystemLogs> system_logs(
+      new SystemLogUploadJob::SystemLogs());
+  for (auto const file_path : kTestSystemLogFileNames) {
+    system_logs->push_back(std::make_pair(file_path, file_path));
+  }
+  return system_logs;
+}
+
+class MockSystemLogDelegate : public SystemLogUploadJob::Delegate {
+ public:
+  explicit MockSystemLogDelegate(
+      scoped_ptr<UploadJob::ErrorCode> upload_job_error_code);
+  ~MockSystemLogDelegate() override;
+
+  void LoadSystemLogs(const LogUploadCallback& upload_callback) override;
+  scoped_ptr<UploadJob> CreateUploadJob(const GURL&,
+                                        UploadJob::Delegate*) override;
+
+ private:
+  scoped_ptr<UploadJob::ErrorCode> upload_job_error_code_;
+};
+
+MockSystemLogDelegate::MockSystemLogDelegate(
+    scoped_ptr<UploadJob::ErrorCode> upload_job_error_code)
+    : upload_job_error_code_(upload_job_error_code.Pass()) {
+}
+
+MockSystemLogDelegate::~MockSystemLogDelegate() {
+}
+
+void MockSystemLogDelegate::LoadSystemLogs(
+    const LogUploadCallback& upload_callback) {
+  scoped_ptr<SystemLogUploadJob::SystemLogs> test_files =
+      GenerateTestSystemLogFiles();
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(upload_callback, base::Owned(test_files.release())));
+}
+
+scoped_ptr<UploadJob> MockSystemLogDelegate::CreateUploadJob(
+    const GURL& upload_url,
+    UploadJob::Delegate* delegate) {
+  return make_scoped_ptr(
+      new MockUploadJob(upload_url, delegate, upload_job_error_code_.Pass()));
+}
+
+}  // namespace
+
+class SystemLogUploadTest : public testing::Test {
+ public:
+  // If |error_code| is a null pointer, the VerifyResult expects the success
+  // callback is invoked, otherwise - the failure callback with the respective
+  // |error_code|.
+  void RunTest(scoped_ptr<UploadJob::ErrorCode> error_code);
+
+ protected:
+  SystemLogUploadTest()
+      : ui_thread_(content::BrowserThread::UI, &run_loop_),
+        task_runner_(new base::TestMockTimeTaskRunner()),
+        weak_factory_(this) {}
+
+  ~SystemLogUploadTest() override {}
+
+  void VerifyResults(bool expected_call) {
+    EXPECT_TRUE(expected_call);
+    run_loop_.Quit();
+  }
+
+  base::MessageLoopForUI run_loop_;
+  content::TestBrowserThread ui_thread_;
+
+ private:
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
+
+  base::WeakPtrFactory<SystemLogUploadTest> weak_factory_;
+  DISALLOW_COPY_AND_ASSIGN(SystemLogUploadTest);
+};
+
+void SystemLogUploadTest::RunTest(scoped_ptr<UploadJob::ErrorCode> error_code) {
+  bool success = !error_code;
+
+  scoped_ptr<SystemLogUploadJob> job(new SystemLogUploadJob(
+      make_scoped_ptr(new MockSystemLogDelegate(error_code.Pass())),
+      base::Bind(&SystemLogUploadTest::VerifyResults,
+                 weak_factory_.GetWeakPtr(), success),
+      base::Bind(&SystemLogUploadTest::VerifyResults,
+                 weak_factory_.GetWeakPtr(), !success)));
+
+  job->Run();
+  run_loop_.Run();
+}
+
+TEST_F(SystemLogUploadTest, Success) {
+  RunTest(nullptr);
+}
+
+TEST_F(SystemLogUploadTest, Failure) {
+  scoped_ptr<UploadJob::ErrorCode> error_code(
+      new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR));
+  RunTest(error_code.Pass());
+}
+
+}  // namespace policy