Home | History | Annotate | Download | only in sync 
      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 "base/run_loop.h"
     11 #include "chrome/browser/sync/supervised_user_signin_manager_wrapper.h"
     12 #include "chrome/common/chrome_switches.h"
     13 #include "components/sync_driver/sync_prefs.h"
     14 #include "testing/gmock/include/gmock/gmock.h"
     15 #include "testing/gtest/include/gtest/gtest.h"
     16 
     17 using ::testing::Return;
     18 
     19 namespace {
     20 
     21 #if defined(ENABLE_PRE_SYNC_BACKUP)
     22 
     23 class MockSigninManagerWrapper : public SupervisedUserSigninManagerWrapper {
     24  public:
     25   MockSigninManagerWrapper() : SupervisedUserSigninManagerWrapper(NULL, NULL) {}
     26 
     27   MOCK_CONST_METHOD0(GetEffectiveUsername, std::string());
     28 };
     29 
     30 class FakeSyncPrefs : public sync_driver::SyncPrefs {
     31  public:
     32   FakeSyncPrefs() : rollback_tries_left_(0) {}
     33 
     34   virtual int GetRemainingRollbackTries() const OVERRIDE {
     35     return rollback_tries_left_;
     36   }
     37 
     38   virtual void SetRemainingRollbackTries(int v) OVERRIDE {
     39     rollback_tries_left_ = v;
     40   }
     41 
     42  private:
     43   int rollback_tries_left_;
     44 };
     45 
     46 class BackupRollbackControllerTest : public testing::Test {
     47  public:
     48   void ControllerCallback(bool start_backup) {
     49     if (start_backup)
     50       backup_started_ = true;
     51     else
     52       rollback_started_ = true;
     53   }
     54 
     55  protected:
     56   virtual void SetUp() OVERRIDE {
     57     backup_started_ = false;
     58     rollback_started_ = false;
     59 
     60     EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
     61         .WillRepeatedly(Return(""));
     62 
     63     controller_.reset(new browser_sync::BackupRollbackController(
     64         &fake_prefs_, &signin_wrapper_,
     65         base::Bind(&BackupRollbackControllerTest::ControllerCallback,
     66                    base::Unretained(this), true),
     67         base::Bind(&BackupRollbackControllerTest::ControllerCallback,
     68                    base::Unretained(this), false)));
     69   }
     70 
     71   void PumpLoop() {
     72     base::RunLoop run_loop;
     73     loop_.PostTask(FROM_HERE, run_loop.QuitClosure());
     74     run_loop.Run();
     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   base::MessageLoop loop_;
     83 };
     84 
     85 TEST_F(BackupRollbackControllerTest, StartBackup) {
     86   EXPECT_TRUE(controller_->StartBackup());
     87   PumpLoop();
     88   EXPECT_TRUE(backup_started_);
     89 }
     90 
     91 TEST_F(BackupRollbackControllerTest, NoBackupIfDisabled) {
     92   CommandLine::ForCurrentProcess()->AppendSwitch(
     93         switches::kSyncDisableBackup);
     94 
     95   base::RunLoop run_loop;
     96   EXPECT_FALSE(controller_->StartBackup());
     97   loop_.PostTask(FROM_HERE, run_loop.QuitClosure());
     98   run_loop.Run();
     99   EXPECT_FALSE(backup_started_);
    100 }
    101 
    102 TEST_F(BackupRollbackControllerTest, StartRollback) {
    103   fake_prefs_.SetRemainingRollbackTries(1);
    104 
    105   EXPECT_TRUE(controller_->StartRollback());
    106   PumpLoop();
    107   EXPECT_TRUE(rollback_started_);
    108   EXPECT_EQ(0, fake_prefs_.GetRemainingRollbackTries());
    109 }
    110 
    111 TEST_F(BackupRollbackControllerTest, NoRollbackIfOutOfTries) {
    112   fake_prefs_.SetRemainingRollbackTries(0);
    113 
    114   EXPECT_FALSE(controller_->StartRollback());
    115   PumpLoop();
    116   EXPECT_FALSE(rollback_started_);
    117 }
    118 
    119 TEST_F(BackupRollbackControllerTest, NoRollbackIfUserSignedIn) {
    120   fake_prefs_.SetRemainingRollbackTries(1);
    121   EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
    122       .Times(1)
    123       .WillOnce(Return("test"));
    124   EXPECT_FALSE(controller_->StartRollback());
    125   EXPECT_EQ(0, fake_prefs_.GetRemainingRollbackTries());
    126 
    127   PumpLoop();
    128   EXPECT_FALSE(backup_started_);
    129   EXPECT_FALSE(rollback_started_);
    130 }
    131 
    132 TEST_F(BackupRollbackControllerTest, NoRollbackIfDisabled) {
    133   fake_prefs_.SetRemainingRollbackTries(1);
    134 
    135   CommandLine::ForCurrentProcess()->AppendSwitch(
    136         switches::kSyncDisableRollback);
    137   EXPECT_FALSE(controller_->StartRollback());
    138   EXPECT_EQ(0, fake_prefs_.GetRemainingRollbackTries());
    139 
    140   PumpLoop();
    141   EXPECT_FALSE(rollback_started_);
    142 }
    143 
    144 #endif
    145 
    146 }  // anonymous namespace
    147 
    148