chrome/browser/sync/backup_rollback_controller_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/sync/backup_rollback_controller.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "chrome/browser/sync/managed_user_signin_manager_wrapper.h"
  11 #include "chrome/common/chrome_switches.h"
  12 #include "components/sync_driver/sync_prefs.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 using ::testing::Return;
  17
  18 namespace {
  19
  20 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
  21
  22 class MockSigninManagerWrapper : public ManagedUserSigninManagerWrapper {
  23  public:
  24   MockSigninManagerWrapper() : ManagedUserSigninManagerWrapper(NULL, NULL) {}
  25
  26   MOCK_CONST_METHOD0(GetEffectiveUsername, std::string());
  27 };
  28
  29 class FakeSyncPrefs : public sync_driver::SyncPrefs {
  30  public:
  31   FakeSyncPrefs() : rollback_tries_left_(0) {}
  32
  33   virtual int GetRemainingRollbackTries() const OVERRIDE {
  34     return rollback_tries_left_;
  35   }
  36
  37   virtual void SetRemainingRollbackTries(int v) OVERRIDE {
  38     rollback_tries_left_ = v;
  39   }
  40
  41  private:
  42   int rollback_tries_left_;
  43 };
  44
  45 class BackupRollbackControllerTest : public testing::Test {
  46  public:
  47   void ControllerCallback(bool start_backup) {
  48     if (start_backup)
  49       backup_started_ = true;
  50     else
  51       rollback_started_ = true;
  52
  53     if (need_loop_quit_)
  54       base::MessageLoop::current()->Quit();
  55   }
  56
  57  protected:
  58   virtual void SetUp() OVERRIDE {
  59     CommandLine::ForCurrentProcess()->AppendSwitch(
  60           switches::kSyncEnableBackupRollback);
  61
  62     backup_started_ = false;
  63     rollback_started_ = false;
  64     need_loop_quit_ = false;
  65
  66     EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
  67         .WillRepeatedly(Return(""));
  68
  69     controller_.reset(new browser_sync::BackupRollbackController(
  70         &fake_prefs_, &signin_wrapper_,
  71         base::Bind(&BackupRollbackControllerTest::ControllerCallback,
  72                    base::Unretained(this), true),
  73         base::Bind(&BackupRollbackControllerTest::ControllerCallback,
  74                    base::Unretained(this), false)));
  75   }
  76
  77   MockSigninManagerWrapper signin_wrapper_;
  78   FakeSyncPrefs fake_prefs_;
  79   scoped_ptr<browser_sync::BackupRollbackController> controller_;
  80   bool backup_started_;
  81   bool rollback_started_;
  82   bool need_loop_quit_;
  83   base::MessageLoop loop_;
  84 };
  85
  86 TEST_F(BackupRollbackControllerTest, DelayStart) {
  87   controller_->Start(base::TimeDelta::FromMilliseconds(100));
  88   EXPECT_FALSE(backup_started_);
  89   need_loop_quit_ = true;
  90   base::MessageLoop::current()->Run();
  91   EXPECT_TRUE(backup_started_);
  92 }
  93
  94 TEST_F(BackupRollbackControllerTest, NoDelayStart) {
  95   controller_->Start(base::TimeDelta());
  96   EXPECT_TRUE(backup_started_);
  97 }
  98
  99 TEST_F(BackupRollbackControllerTest, NoStartWithUserSignedIn) {
 100   EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
 101       .Times(1)
 102       .WillOnce(Return("test"));
 103   controller_->Start(base::TimeDelta());
 104   EXPECT_FALSE(backup_started_);
 105   EXPECT_FALSE(rollback_started_);
 106 }
 107
 108 TEST_F(BackupRollbackControllerTest, StartOnUserSignedOut) {
 109   EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
 110       .Times(2)
 111       .WillOnce(Return("test"))
 112       .WillOnce(Return(""));
 113   controller_->Start(base::TimeDelta());
 114   EXPECT_FALSE(backup_started_);
 115   EXPECT_FALSE(rollback_started_);
 116
 117   // 2nd time no signed-in user. Starts backup.
 118   controller_->Start(base::TimeDelta());
 119   EXPECT_TRUE(backup_started_);
 120 }
 121
 122 TEST_F(BackupRollbackControllerTest, StartRollback) {
 123   EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
 124       .Times(2)
 125       .WillOnce(Return("test"))
 126       .WillOnce(Return(""));
 127   controller_->Start(base::TimeDelta());
 128   EXPECT_FALSE(backup_started_);
 129   EXPECT_FALSE(rollback_started_);
 130
 131   controller_->OnRollbackReceived();
 132   controller_->Start(base::TimeDelta());
 133   EXPECT_TRUE(rollback_started_);
 134 }
 135
 136 TEST_F(BackupRollbackControllerTest, RollbackOnBrowserStart) {
 137   fake_prefs_.SetRemainingRollbackTries(1);
 138   controller_->Start(base::TimeDelta());
 139   EXPECT_TRUE(rollback_started_);
 140 }
 141
 142 TEST_F(BackupRollbackControllerTest, BackupAfterRollbackDone) {
 143   fake_prefs_.SetRemainingRollbackTries(3);
 144   controller_->Start(base::TimeDelta());
 145   EXPECT_TRUE(rollback_started_);
 146   EXPECT_FALSE(backup_started_);
 147
 148   controller_->OnRollbackDone();
 149   controller_->Start(base::TimeDelta());
 150   EXPECT_TRUE(backup_started_);
 151 }
 152
 153 TEST_F(BackupRollbackControllerTest, GiveUpRollback) {
 154   fake_prefs_.SetRemainingRollbackTries(3);
 155   for (int i = 0; i < 3; ++i) {
 156     controller_->Start(base::TimeDelta());
 157     EXPECT_TRUE(rollback_started_);
 158     EXPECT_FALSE(backup_started_);
 159     rollback_started_ = false;
 160   }
 161
 162   controller_->Start(base::TimeDelta());
 163   EXPECT_FALSE(rollback_started_);
 164   EXPECT_TRUE(backup_started_);
 165 }
 166
 167 #endif
 168
 169 }  // anonymous namespace
 170