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 "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   int GetRemainingRollbackTries() const override {
  35     return rollback_tries_left_;
  36   }
  37
  38   void SetRemainingRollbackTries(int v) override { rollback_tries_left_ = v; }
  39
  40  private:
  41   int rollback_tries_left_;
  42 };
  43
  44 class BackupRollbackControllerTest : public testing::Test {
  45  public:
  46   void ControllerCallback(bool start_backup) {
  47     if (start_backup)
  48       backup_started_ = true;
  49     else
  50       rollback_started_ = true;
  51   }
  52
  53  protected:
  54   void SetUp() override {
  55     backup_started_ = false;
  56     rollback_started_ = false;
  57
  58     EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
  59         .WillRepeatedly(Return(""));
  60
  61     controller_.reset(new browser_sync::BackupRollbackController(
  62         &fake_prefs_, &signin_wrapper_,
  63         base::Bind(&BackupRollbackControllerTest::ControllerCallback,
  64                    base::Unretained(this), true),
  65         base::Bind(&BackupRollbackControllerTest::ControllerCallback,
  66                    base::Unretained(this), false)));
  67   }
  68
  69   void PumpLoop() {
  70     base::RunLoop run_loop;
  71     loop_.PostTask(FROM_HERE, run_loop.QuitClosure());
  72     run_loop.Run();
  73   }
  74
  75   MockSigninManagerWrapper signin_wrapper_;
  76   FakeSyncPrefs fake_prefs_;
  77   scoped_ptr<browser_sync::BackupRollbackController> controller_;
  78   bool backup_started_;
  79   bool rollback_started_;
  80   base::MessageLoop loop_;
  81 };
  82
  83 TEST_F(BackupRollbackControllerTest, StartBackup) {
  84   EXPECT_TRUE(controller_->StartBackup());
  85   PumpLoop();
  86   EXPECT_TRUE(backup_started_);
  87 }
  88
  89 TEST_F(BackupRollbackControllerTest, NoBackupIfDisabled) {
  90   base::CommandLine::ForCurrentProcess()->AppendSwitch(
  91       switches::kSyncDisableBackup);
  92
  93   base::RunLoop run_loop;
  94   EXPECT_FALSE(controller_->StartBackup());
  95   loop_.PostTask(FROM_HERE, run_loop.QuitClosure());
  96   run_loop.Run();
  97   EXPECT_FALSE(backup_started_);
  98 }
  99
 100 TEST_F(BackupRollbackControllerTest, StartRollback) {
 101   fake_prefs_.SetRemainingRollbackTries(1);
 102
 103   EXPECT_TRUE(controller_->StartRollback());
 104   PumpLoop();
 105   EXPECT_TRUE(rollback_started_);
 106   EXPECT_EQ(0, fake_prefs_.GetRemainingRollbackTries());
 107 }
 108
 109 TEST_F(BackupRollbackControllerTest, NoRollbackIfOutOfTries) {
 110   fake_prefs_.SetRemainingRollbackTries(0);
 111
 112   EXPECT_FALSE(controller_->StartRollback());
 113   PumpLoop();
 114   EXPECT_FALSE(rollback_started_);
 115 }
 116
 117 TEST_F(BackupRollbackControllerTest, NoRollbackIfUserSignedIn) {
 118   fake_prefs_.SetRemainingRollbackTries(1);
 119   EXPECT_CALL(signin_wrapper_, GetEffectiveUsername())
 120       .Times(1)
 121       .WillOnce(Return("test"));
 122   EXPECT_FALSE(controller_->StartRollback());
 123   EXPECT_EQ(0, fake_prefs_.GetRemainingRollbackTries());
 124
 125   PumpLoop();
 126   EXPECT_FALSE(backup_started_);
 127   EXPECT_FALSE(rollback_started_);
 128 }
 129
 130 TEST_F(BackupRollbackControllerTest, NoRollbackIfDisabled) {
 131   fake_prefs_.SetRemainingRollbackTries(1);
 132
 133   base::CommandLine::ForCurrentProcess()->AppendSwitch(
 134       switches::kSyncDisableRollback);
 135   EXPECT_FALSE(controller_->StartRollback());
 136   EXPECT_EQ(0, fake_prefs_.GetRemainingRollbackTries());
 137
 138   PumpLoop();
 139   EXPECT_FALSE(rollback_started_);
 140 }
 141
 142 #endif
 143
 144 }  // anonymous namespace
 145