Add BackupRollbackController for starting backup/rollback

chrome/browser/sync/backup_rollback_controller_unittest.cc

+// Copyright (c) 2014 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 "chrome/browser/sync/backup_rollback_controller.h"
+
+#include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "chrome/browser/sync/managed_user_signin_manager_wrapper.h"
+#include "chrome/common/chrome_switches.h"
+#include "components/sync_driver/sync_prefs.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::Return;
+
+namespace {
+
+#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
+
+class MockSigninManagerWrapper : public ManagedUserSigninManagerWrapper {
+ public:
+  MockSigninManagerWrapper() : ManagedUserSigninManagerWrapper(NULL, NULL) {}
+
+  MOCK_CONST_METHOD0(GetEffectiveUsername, std::string());
+};
+
+class FakeSyncPrefs : public sync_driver::SyncPrefs {
+ public:
+  FakeSyncPrefs() : rollback_tries_left_(0) {}
+
+  virtual int GetRemainingRollbackTries() const OVERRIDE {
+    return rollback_tries_left_;
+  }
+
+  virtual void SetRemainingRollbackTries(int v) OVERRIDE {
+    rollback_tries_left_ = v;
+  }
+
+ private:
+  int rollback_tries_left_;
+};
+
+class BackupRollbackControllerTest : public testing::Test {
+ public:
+  void ControllerCallback(bool start_backup) {
+    if (start_backup)
+      backup_started_ = true;
+    else
+      rollback_started_ = true;
+
+    if (need_loop_quit_)
+      base::MessageLoop::current()->Quit();
+  }
+
+ protected:
+  virtual void SetUp() OVERRIDE {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kSyncEnableBackupRollback);
+
+    backup_started_ = false;
+    rollback_started_ = false;
+    need_loop_quit_ = false;
+
+    EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
+        .WillRepeatedly(Return(""));
+
+    controller_.reset(new browser_sync::BackupRollbackController(
+        &fake_prefs_, &signin_wrapper_,
+        base::Bind(&BackupRollbackControllerTest::ControllerCallback,
+                   base::Unretained(this), true),
+        base::Bind(&BackupRollbackControllerTest::ControllerCallback,
+                   base::Unretained(this), false)));
+  }
+
+  MockSigninManagerWrapper signin_wrapper_;
+  FakeSyncPrefs fake_prefs_;
+  scoped_ptr<browser_sync::BackupRollbackController> controller_;
+  bool backup_started_;
+  bool rollback_started_;
+  bool need_loop_quit_;
+  base::MessageLoop loop_;
+};
+
+TEST_F(BackupRollbackControllerTest, DelayStart) {
+  controller_->Reset(base::TimeDelta::FromMilliseconds(100));
+  EXPECT_FALSE(backup_started_);
+  need_loop_quit_ = true;
+  base::MessageLoop::current()->Run();
+  EXPECT_TRUE(backup_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, NoDelayStart) {
+  controller_->Reset(base::TimeDelta());
+  EXPECT_TRUE(backup_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, NoStartWithUserSignedIn) {
+  EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
+      .Times(1)
+      .WillOnce(Return("test"));
+  controller_->Reset(base::TimeDelta());
+  EXPECT_FALSE(backup_started_);
+  EXPECT_FALSE(rollback_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, StartOnUserSignedOut) {
+  EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
+      .Times(2)
+      .WillOnce(Return("test"))
+      .WillOnce(Return(""));
+  controller_->Reset(base::TimeDelta());
+  EXPECT_FALSE(backup_started_);
+  EXPECT_FALSE(rollback_started_);
+
+  // 2nd time no signed-in user. Starts backup.
+  controller_->Reset(base::TimeDelta());
+  EXPECT_TRUE(backup_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, StartRollback) {
+  EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
+      .Times(2)
+      .WillOnce(Return("test"))
+      .WillOnce(Return(""));
+  controller_->Reset(base::TimeDelta());
+  EXPECT_FALSE(backup_started_);
+  EXPECT_FALSE(rollback_started_);
+
+  controller_->OnRollbackReceived();
+  controller_->Reset(base::TimeDelta());
+  EXPECT_TRUE(rollback_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, RollbackOnBrowserStart) {
+  fake_prefs_.SetRemainingRollbackTries(1);
+  controller_->Reset(base::TimeDelta());
+  EXPECT_TRUE(rollback_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, BackupAfterRollbackDone) {
+  fake_prefs_.SetRemainingRollbackTries(3);
+  controller_->Reset(base::TimeDelta());
+  EXPECT_TRUE(rollback_started_);
+  EXPECT_FALSE(backup_started_);
+
+  controller_->OnRollbackDone();
+  controller_->Reset(base::TimeDelta());
+  EXPECT_TRUE(backup_started_);
+}
+
+TEST_F(BackupRollbackControllerTest, GiveUpRollback) {
+  fake_prefs_.SetRemainingRollbackTries(3);
+  for (int i = 0; i < 3; ++i) {
+    controller_->Reset(base::TimeDelta());
+    EXPECT_TRUE(rollback_started_);
+    EXPECT_FALSE(backup_started_);
+    rollback_started_ = false;
+  }
+
+  controller_->Reset(base::TimeDelta());
+  EXPECT_FALSE(rollback_started_);
+  EXPECT_TRUE(backup_started_);
+}
+
+#endif
+
+}  // anonymous namespace
+