Added policy to disable/enable a system log upload.

chrome/browser/chromeos/policy/system_log_uploader_unittest.cc

 // 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/strings/stringprintf.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/policy/system_log_uploader.h"
+#include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.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[] = {"name1.txt", "name32.txt"};
 
@@ skipping 84 matching lines @@
 // MockSystemLogDelegate - mock class that creates an upload job and runs upload
 // callback.
 class MockSystemLogDelegate : public SystemLogUploader::Delegate {
  public:
   MockSystemLogDelegate(bool is_upload_error,
                         const SystemLogUploader::SystemLogs& system_logs)
       : is_upload_error_(is_upload_error), system_logs_(system_logs) {}
   ~MockSystemLogDelegate() override {}
 
   void LoadSystemLogs(const LogUploadCallback& upload_callback) override {
+    EXPECT_TRUE(is_upload_allowed_);
     upload_callback.Run(
         make_scoped_ptr(new SystemLogUploader::SystemLogs(system_logs_)));
   }
 
   scoped_ptr<UploadJob> CreateUploadJob(
       const GURL& url,
       UploadJob::Delegate* delegate) override {
     return make_scoped_ptr(new MockUploadJob(url, delegate, is_upload_error_,
                                              system_logs_.size()));
   }
 
+  void set_upload_allowed(bool is_upload_allowed) {
+    is_upload_allowed_ = is_upload_allowed;
+  }
+
  private:
+  bool is_upload_allowed_;
   bool is_upload_error_;
   SystemLogUploader::SystemLogs system_logs_;
 };
 
 }  //  namespace
 
 class SystemLogUploaderTest : public testing::Test {
  public:
   SystemLogUploaderTest() : task_runner_(new base::TestSimpleTaskRunner()) {}
 
+  void TearDown() override { content::RunAllBlockingPoolTasksUntilIdle(); }
+
   // Given a pending task to upload system logs.
-  void RunPendingUploadTaskAndCheckNext(const SystemLogUploader& uploader,
-                                        base::TimeDelta expected_delay) {
+  void RunPendingUploadTaskAndCheckNext(base::TimeDelta expected_delay) {
     EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
     task_runner_->RunPendingTasks();
 
     // The previous task should have uploaded another log upload task.
     EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
-    CheckPendingTaskDelay(uploader, expected_delay);
+    CheckPendingTaskDelay(expected_delay);
   }
 
-  void CheckPendingTaskDelay(const SystemLogUploader& uploader,
-                             base::TimeDelta expected_delay) {
+  void CheckPendingTaskDelay(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);
+    EXPECT_GE(next_task, uploader_->last_upload_attempt() + expected_delay);
   }
 
+  void InitTestCase(scoped_ptr<MockSystemLogDelegate> delegate) {
+    // Replace settings provider must be after observer creation in the system

[Andrew T Wilson (Slow), 2015/08/13 11:26:18]

Why is the ordering important? I'm not sure I understand?

[Polina Bondarenko, 2015/08/13 14:51:16]

Yes, you're right, it's not important, removed it.

+    // log uploader's constructor.
+    uploader_.reset(new SystemLogUploader(delegate.Pass(), task_runner_));
+    settings_helper_.ReplaceProvider(chromeos::kLogUploadEnabled);
+  }
+
+  void DestroyTestCase() { settings_helper_.RestoreProvider(); }
+
+ protected:
+  content::TestBrowserThreadBundle thread_bundle_;
+  chromeos::ScopedCrosSettingsTestHelper settings_helper_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  scoped_ptr<SystemLogUploader> uploader_;
 };
 
+// Turn off system log uploads.
+TEST_F(SystemLogUploaderTest, Basic) {
+  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
+  syslog_delegate->set_upload_allowed(false);
+  InitTestCase(syslog_delegate.Pass());

[Andrew T Wilson (Slow), 2015/08/13 11:26:18]

It's a bit weird to have this Init/DestroyTestCase() stuff. Is it not possible
to have this in the SetUp()/TearDown() code?

[Polina Bondarenko, 2015/08/13 14:51:17]

Yes, it's possible, done.

+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, false);
+
+  task_runner_->RunPendingTasks();
+  DestroyTestCase();
+}
+
 // One success task pending.
 TEST_F(SystemLogUploaderTest, SuccessTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  SystemLogUploader uploader(make_scoped_ptr(new MockSystemLogDelegate(
-                                 false, SystemLogUploader::SystemLogs())),
-                             task_runner_);
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
+  syslog_delegate->set_upload_allowed(true);
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
-  RunPendingUploadTaskAndCheckNext(
-      uploader, base::TimeDelta::FromMilliseconds(
-                    SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  DestroyTestCase();
 }
 
 // Three failed responses recieved.
 TEST_F(SystemLogUploaderTest, ThreeFailureTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  SystemLogUploader uploader(make_scoped_ptr(new MockSystemLogDelegate(
-                                 true, SystemLogUploader::SystemLogs())),
-                             task_runner_);
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
+  syslog_delegate->set_upload_allowed(true);
 
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
   // Do not retry two times consequentially.
-  RunPendingUploadTaskAndCheckNext(uploader,
-                                   base::TimeDelta::FromMilliseconds(
-                                       SystemLogUploader::kErrorUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kErrorUploadDelayMs));
   // We are using the kDefaultUploadDelayMs and not the kErrorUploadDelayMs here
   // because there's just one retry.
-  RunPendingUploadTaskAndCheckNext(
-      uploader, base::TimeDelta::FromMilliseconds(
-                    SystemLogUploader::kDefaultUploadDelayMs));
-  RunPendingUploadTaskAndCheckNext(uploader,
-                                   base::TimeDelta::FromMilliseconds(
-                                       SystemLogUploader::kErrorUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kErrorUploadDelayMs));
+  DestroyTestCase();
 }
 
 // Check header fields of system log files to upload.
 TEST_F(SystemLogUploaderTest, CheckHeaders) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles();
-  SystemLogUploader uploader(
-      make_scoped_ptr(new MockSystemLogDelegate(false, system_logs)),
-      task_runner_);
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(false, system_logs));
+  syslog_delegate->set_upload_allowed(true);
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
-  RunPendingUploadTaskAndCheckNext(
-      uploader, base::TimeDelta::FromMilliseconds(
-                    SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  DestroyTestCase();
+}
+
+// Disable system log uploads after one failed log upload.
+TEST_F(SystemLogUploaderTest, DisableLogUpload) {
+  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
+  MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
+  mock_delegate->set_upload_allowed(true);
+
+  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kErrorUploadDelayMs));
+
+  // Disable log upload and check that frequency is usual, because there is no
+  // errors, we should not upload logs.
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, false);
+  mock_delegate->set_upload_allowed(false);
+  task_runner_->RunPendingTasks();
+
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  DestroyTestCase();
 }
 
 }  // namespace policy