chrome/browser/sync/sync_ui_util_unittest.cc

   1 // Copyright (c) 2012 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 <set>
   6 #include "base/basictypes.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chrome/browser/profiles/profile.h"
   9 #include "chrome/browser/signin/fake_signin_manager.h"
  10 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
  11 #include "chrome/browser/sync/profile_sync_service_mock.h"
  12 #include "chrome/browser/sync/sync_ui_util.h"
  13 #include "chrome/grit/generated_resources.h"
  14 #include "components/signin/core/browser/fake_auth_status_provider.h"
  15 #include "components/signin/core/browser/profile_oauth2_token_service.h"
  16 #include "components/signin/core/browser/signin_manager.h"
  17 #include "content/public/test/test_browser_thread.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "testing/gmock/include/gmock/gmock-actions.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "ui/base/l10n/l10n_util.h"
  23
  24 using ::testing::AtMost;
  25 using ::testing::NiceMock;
  26 using ::testing::Return;
  27 using ::testing::ReturnRef;
  28 using ::testing::SetArgPointee;
  29 using ::testing::_;
  30 using content::BrowserThread;
  31
  32 // A number of distinct states of the ProfileSyncService can be generated for
  33 // tests.
  34 enum DistinctState {
  35   STATUS_CASE_SETUP_IN_PROGRESS,
  36   STATUS_CASE_SETUP_ERROR,
  37   STATUS_CASE_AUTHENTICATING,
  38   STATUS_CASE_AUTH_ERROR,
  39   STATUS_CASE_PROTOCOL_ERROR,
  40   STATUS_CASE_PASSPHRASE_ERROR,
  41   STATUS_CASE_SYNCED,
  42   STATUS_CASE_SYNC_DISABLED_BY_POLICY,
  43   NUMBER_OF_STATUS_CASES
  44 };
  45
  46 namespace {
  47
  48 const char kTestUser[] = "test_user@test.com";
  49
  50 #if !defined(OS_CHROMEOS)
  51 // Utility function to test that GetStatusLabelsForSyncGlobalError returns
  52 // the correct results for the given states.
  53 void VerifySyncGlobalErrorResult(NiceMock<ProfileSyncServiceMock>* service,
  54                                  GoogleServiceAuthError::State error_state,
  55                                  bool is_signed_in,
  56                                  bool is_error) {
  57   EXPECT_CALL(*service, HasSyncSetupCompleted())
  58               .WillRepeatedly(Return(is_signed_in));
  59
  60   GoogleServiceAuthError auth_error(error_state);
  61   EXPECT_CALL(*service, GetAuthError()).WillRepeatedly(ReturnRef(auth_error));
  62
  63   base::string16 label1, label2, label3;
  64   sync_ui_util::GetStatusLabelsForSyncGlobalError(
  65       service, &label1, &label2, &label3);
  66   EXPECT_EQ(label1.empty(), !is_error);
  67   EXPECT_EQ(label2.empty(), !is_error);
  68   EXPECT_EQ(label3.empty(), !is_error);
  69 }
  70 #endif
  71
  72 } // namespace
  73
  74
  75 class SyncUIUtilTest : public testing::Test {
  76  private:
  77   content::TestBrowserThreadBundle thread_bundle_;
  78 };
  79
  80 #if !defined(OS_CHROMEOS)
  81 // Test that GetStatusLabelsForSyncGlobalError returns an error if a
  82 // passphrase is required.
  83 TEST_F(SyncUIUtilTest, PassphraseGlobalError) {
  84   scoped_ptr<Profile> profile(
  85       ProfileSyncServiceMock::MakeSignedInTestingProfile());
  86   NiceMock<ProfileSyncServiceMock> service(profile.get());
  87   browser_sync::SyncBackendHost::Status status;
  88   EXPECT_CALL(service, QueryDetailedSyncStatus(_))
  89               .WillRepeatedly(Return(false));
  90   EXPECT_CALL(service, IsPassphraseRequired())
  91               .WillRepeatedly(Return(true));
  92   EXPECT_CALL(service, IsPassphraseRequiredForDecryption())
  93               .WillRepeatedly(Return(true));
  94
  95   VerifySyncGlobalErrorResult(&service,
  96                               GoogleServiceAuthError::NONE,
  97                               true /* signed in */,
  98                               true /* error */);
  99 }
 100
 101 // Test that GetStatusLabelsForSyncGlobalError returns an error if a
 102 // passphrase is required and not for auth errors.
 103 TEST_F(SyncUIUtilTest, AuthAndPassphraseGlobalError) {
 104   scoped_ptr<Profile> profile(
 105       ProfileSyncServiceMock::MakeSignedInTestingProfile());
 106   NiceMock<ProfileSyncServiceMock> service(profile.get());
 107   browser_sync::SyncBackendHost::Status status;
 108   EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 109               .WillRepeatedly(Return(false));
 110
 111   EXPECT_CALL(service, IsPassphraseRequired())
 112               .WillRepeatedly(Return(true));
 113   EXPECT_CALL(service, IsPassphraseRequiredForDecryption())
 114               .WillRepeatedly(Return(true));
 115   EXPECT_CALL(service, HasSyncSetupCompleted())
 116               .WillRepeatedly(Return(true));
 117
 118   GoogleServiceAuthError auth_error(
 119       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
 120   EXPECT_CALL(service, GetAuthError()).WillRepeatedly(ReturnRef(auth_error));
 121   base::string16 menu_label, label2, label3;
 122   sync_ui_util::GetStatusLabelsForSyncGlobalError(
 123       &service, &menu_label, &label2, &label3);
 124   // Make sure we are still displaying the passphrase error badge (don't show
 125   // auth errors through SyncUIUtil).
 126   EXPECT_EQ(menu_label, l10n_util::GetStringUTF16(
 127       IDS_SYNC_PASSPHRASE_ERROR_WRENCH_MENU_ITEM));
 128 }
 129
 130 // Test that GetStatusLabelsForSyncGlobalError does not indicate errors for
 131 // auth errors (these are reported through SigninGlobalError).
 132 TEST_F(SyncUIUtilTest, AuthStateGlobalError) {
 133   scoped_ptr<Profile> profile(
 134       ProfileSyncServiceMock::MakeSignedInTestingProfile());
 135   NiceMock<ProfileSyncServiceMock> service(profile.get());
 136
 137   browser_sync::SyncBackendHost::Status status;
 138   EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 139               .WillRepeatedly(Return(false));
 140
 141   GoogleServiceAuthError::State table[] = {
 142     GoogleServiceAuthError::NONE,
 143     GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS,
 144     GoogleServiceAuthError::USER_NOT_SIGNED_UP,
 145     GoogleServiceAuthError::CONNECTION_FAILED,
 146     GoogleServiceAuthError::CAPTCHA_REQUIRED,
 147     GoogleServiceAuthError::ACCOUNT_DELETED,
 148     GoogleServiceAuthError::ACCOUNT_DISABLED,
 149     GoogleServiceAuthError::SERVICE_UNAVAILABLE,
 150     GoogleServiceAuthError::TWO_FACTOR,
 151     GoogleServiceAuthError::REQUEST_CANCELED,
 152     GoogleServiceAuthError::HOSTED_NOT_ALLOWED
 153   };
 154
 155   FakeSigninManagerBase signin(profile.get());
 156   for (size_t i = 0; i < arraysize(table); ++i) {
 157     VerifySyncGlobalErrorResult(&service,
 158                                 table[i],
 159                                 true /* signed in */,
 160                                 false /* no error */);
 161     VerifySyncGlobalErrorResult(&service,
 162                                 table[i],
 163                                 false /* not signed in */,
 164                                 false /* no error */);
 165   }
 166 }
 167 #endif
 168
 169 // TODO(tim): This shouldn't be required. r194857 removed the
 170 // AuthInProgress override from FakeSigninManager, which meant this test started
 171 // using the "real" SigninManager AuthInProgress logic. Without that override,
 172 // it's no longer possible to test both chrome os + desktop flows as part of the
 173 // same test, because AuthInProgress is always false on chrome os. Most of the
 174 // tests are unaffected, but STATUS_CASE_AUTHENTICATING can't exist in both
 175 // versions, so it we will require two separate tests, one using SigninManager
 176 // and one using SigninManagerBase (which require different setup procedures.
 177 class FakeSigninManagerForSyncUIUtilTest : public FakeSigninManagerBase {
 178  public:
 179   explicit FakeSigninManagerForSyncUIUtilTest(Profile* profile)
 180       : FakeSigninManagerBase(profile), auth_in_progress_(false) {
 181     Initialize(NULL);
 182   }
 183
 184   virtual ~FakeSigninManagerForSyncUIUtilTest() {
 185   }
 186
 187   virtual bool AuthInProgress() const override {
 188     return auth_in_progress_;
 189   }
 190
 191   void set_auth_in_progress() {
 192     auth_in_progress_ = true;
 193   }
 194
 195  private:
 196   bool auth_in_progress_;
 197 };
 198
 199 // Loads a ProfileSyncServiceMock to emulate one of a number of distinct cases
 200 // in order to perform tests on the generated messages.
 201 void GetDistinctCase(ProfileSyncServiceMock& service,
 202                      FakeSigninManagerForSyncUIUtilTest* signin,
 203                      FakeAuthStatusProvider* provider,
 204                      int caseNumber) {
 205   // Auth Error object is returned by reference in mock and needs to stay in
 206   // scope throughout test, so it is owned by calling method. However it is
 207   // immutable so can only be allocated in this method.
 208   switch (caseNumber) {
 209     case STATUS_CASE_SETUP_IN_PROGRESS: {
 210       EXPECT_CALL(service, HasSyncSetupCompleted())
 211                   .WillRepeatedly(Return(false));
 212       EXPECT_CALL(service, FirstSetupInProgress())
 213                   .WillRepeatedly(Return(true));
 214       browser_sync::SyncBackendHost::Status status;
 215       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 216                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 217                                   Return(false)));
 218       return;
 219     }
 220    case STATUS_CASE_SETUP_ERROR: {
 221       EXPECT_CALL(service, HasSyncSetupCompleted())
 222                   .WillRepeatedly(Return(false));
 223       EXPECT_CALL(service, FirstSetupInProgress())
 224                   .WillRepeatedly(Return(false));
 225       EXPECT_CALL(service, HasUnrecoverableError())
 226                   .WillRepeatedly(Return(true));
 227       browser_sync::SyncBackendHost::Status status;
 228       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 229                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 230                                   Return(false)));
 231       return;
 232     }
 233     case STATUS_CASE_AUTHENTICATING: {
 234       EXPECT_CALL(service, HasSyncSetupCompleted())
 235                   .WillRepeatedly(Return(true));
 236       EXPECT_CALL(service, SyncActive()).WillRepeatedly(Return(true));
 237       EXPECT_CALL(service, IsPassphraseRequired())
 238                   .WillRepeatedly(Return(false));
 239       browser_sync::SyncBackendHost::Status status;
 240       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 241                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 242                                   Return(false)));
 243       EXPECT_CALL(service, HasUnrecoverableError())
 244                   .WillRepeatedly(Return(false));
 245       signin->set_auth_in_progress();
 246       return;
 247     }
 248     case STATUS_CASE_AUTH_ERROR: {
 249       EXPECT_CALL(service, HasSyncSetupCompleted())
 250                   .WillRepeatedly(Return(true));
 251       EXPECT_CALL(service, SyncActive()).WillRepeatedly(Return(true));
 252       EXPECT_CALL(service, IsPassphraseRequired())
 253                   .WillRepeatedly(Return(false));
 254       browser_sync::SyncBackendHost::Status status;
 255       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 256                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 257                                   Return(false)));
 258       provider->SetAuthError(
 259           kTestUser,
 260           kTestUser,
 261           GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
 262       EXPECT_CALL(service, HasUnrecoverableError())
 263                   .WillRepeatedly(Return(false));
 264       return;
 265     }
 266     case STATUS_CASE_PROTOCOL_ERROR: {
 267       EXPECT_CALL(service, HasSyncSetupCompleted())
 268                   .WillRepeatedly(Return(true));
 269       EXPECT_CALL(service, SyncActive()).WillRepeatedly(Return(true));
 270       EXPECT_CALL(service, IsPassphraseRequired())
 271                   .WillRepeatedly(Return(false));
 272       syncer::SyncProtocolError protocolError;
 273       protocolError.action = syncer::STOP_AND_RESTART_SYNC;
 274       browser_sync::SyncBackendHost::Status status;
 275       status.sync_protocol_error = protocolError;
 276       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 277                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 278                                   Return(false)));
 279       EXPECT_CALL(service, HasUnrecoverableError())
 280                   .WillRepeatedly(Return(false));
 281       return;
 282     }
 283     case STATUS_CASE_PASSPHRASE_ERROR: {
 284       EXPECT_CALL(service, HasSyncSetupCompleted())
 285                   .WillRepeatedly(Return(true));
 286       EXPECT_CALL(service, SyncActive()).WillRepeatedly(Return(true));
 287       browser_sync::SyncBackendHost::Status status;
 288       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 289                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 290                                   Return(false)));
 291       EXPECT_CALL(service, HasUnrecoverableError())
 292                   .WillRepeatedly(Return(false));
 293       EXPECT_CALL(service, IsPassphraseRequired())
 294                   .WillRepeatedly(Return(true));
 295       EXPECT_CALL(service, IsPassphraseRequiredForDecryption())
 296                   .WillRepeatedly(Return(true));
 297       return;
 298     }
 299     case STATUS_CASE_SYNCED: {
 300       EXPECT_CALL(service, HasSyncSetupCompleted())
 301               .WillRepeatedly(Return(true));
 302       EXPECT_CALL(service, SyncActive()).WillRepeatedly(Return(true));
 303       EXPECT_CALL(service, IsPassphraseRequired())
 304                   .WillRepeatedly(Return(false));
 305       browser_sync::SyncBackendHost::Status status;
 306       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 307                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 308                                   Return(false)));
 309       EXPECT_CALL(service, HasUnrecoverableError())
 310                   .WillRepeatedly(Return(false));
 311       EXPECT_CALL(service, IsPassphraseRequired())
 312                   .WillRepeatedly(Return(false));
 313       return;
 314     }
 315     case STATUS_CASE_SYNC_DISABLED_BY_POLICY: {
 316       EXPECT_CALL(service, IsManaged()).WillRepeatedly(Return(true));
 317       EXPECT_CALL(service, HasSyncSetupCompleted())
 318           .WillRepeatedly(Return(false));
 319       EXPECT_CALL(service, SyncActive()).WillRepeatedly(Return(false));
 320       EXPECT_CALL(service, IsPassphraseRequired())
 321                   .WillRepeatedly(Return(false));
 322       browser_sync::SyncBackendHost::Status status;
 323       EXPECT_CALL(service, QueryDetailedSyncStatus(_))
 324                   .WillRepeatedly(DoAll(SetArgPointee<0>(status),
 325                                   Return(false)));
 326       EXPECT_CALL(service, HasUnrecoverableError())
 327                   .WillRepeatedly(Return(false));
 328       return;
 329     }
 330     default:
 331       NOTREACHED();
 332   }
 333 }
 334
 335 // This test ensures that a each distinctive ProfileSyncService statuses
 336 // will return a unique combination of status and link messages from
 337 // GetStatusLabels().
 338 TEST_F(SyncUIUtilTest, DistinctCasesReportUniqueMessageSets) {
 339   std::set<base::string16> messages;
 340   for (int idx = 0; idx != NUMBER_OF_STATUS_CASES; idx++) {
 341     scoped_ptr<Profile> profile(new TestingProfile());
 342     ProfileSyncServiceMock service(profile.get());
 343     GoogleServiceAuthError error = GoogleServiceAuthError::AuthErrorNone();
 344     EXPECT_CALL(service, GetAuthError()).WillRepeatedly(ReturnRef(error));
 345     FakeSigninManagerForSyncUIUtilTest signin(profile.get());
 346     signin.SetAuthenticatedUsername(kTestUser);
 347     scoped_ptr<FakeAuthStatusProvider> provider(new FakeAuthStatusProvider(
 348         ProfileOAuth2TokenServiceFactory::GetForProfile(profile.get())->
 349             signin_error_controller()));
 350     GetDistinctCase(service, &signin, provider.get(), idx);
 351     base::string16 status_label;
 352     base::string16 link_label;
 353     sync_ui_util::GetStatusLabels(&service,
 354                                   signin,
 355                                   sync_ui_util::WITH_HTML,
 356                                   &status_label,
 357                                   &link_label);
 358     // If the status and link message combination is already present in the set
 359     // of messages already seen, this is a duplicate rather than a unique
 360     // message, and the test has failed.
 361     EXPECT_FALSE(status_label.empty()) <<
 362         "Empty status label returned for case #" << idx;
 363     base::string16 combined_label =
 364         status_label + base::ASCIIToUTF16("#") + link_label;
 365     EXPECT_TRUE(messages.find(combined_label) == messages.end()) <<
 366         "Duplicate message for case #" << idx << ": " << combined_label;
 367     messages.insert(combined_label);
 368     testing::Mock::VerifyAndClearExpectations(&service);
 369     testing::Mock::VerifyAndClearExpectations(&signin);
 370     EXPECT_CALL(service, GetAuthError()).WillRepeatedly(ReturnRef(error));
 371     provider.reset();
 372     signin.Shutdown();
 373   }
 374 }
 375
 376 // This test ensures that the html_links parameter on GetStatusLabels() is
 377 // honored.
 378 TEST_F(SyncUIUtilTest, HtmlNotIncludedInStatusIfNotRequested) {
 379   for (int idx = 0; idx != NUMBER_OF_STATUS_CASES; idx++) {
 380     scoped_ptr<Profile> profile(
 381         ProfileSyncServiceMock::MakeSignedInTestingProfile());
 382     ProfileSyncServiceMock service(profile.get());
 383     GoogleServiceAuthError error = GoogleServiceAuthError::AuthErrorNone();
 384     EXPECT_CALL(service, GetAuthError()).WillRepeatedly(ReturnRef(error));
 385     FakeSigninManagerForSyncUIUtilTest signin(profile.get());
 386     signin.SetAuthenticatedUsername(kTestUser);
 387     scoped_ptr<FakeAuthStatusProvider> provider(new FakeAuthStatusProvider(
 388         ProfileOAuth2TokenServiceFactory::GetForProfile(profile.get())->
 389             signin_error_controller()));
 390     GetDistinctCase(service, &signin, provider.get(), idx);
 391     base::string16 status_label;
 392     base::string16 link_label;
 393     sync_ui_util::GetStatusLabels(&service,
 394                                   signin,
 395                                   sync_ui_util::PLAIN_TEXT,
 396                                   &status_label,
 397                                   &link_label);
 398
 399     // Ensures a search for string 'href' (found in links, not a string to be
 400     // found in an English language message) fails when links are excluded from
 401     // the status label.
 402     EXPECT_FALSE(status_label.empty());
 403     EXPECT_EQ(status_label.find(base::ASCIIToUTF16("href")),
 404               base::string16::npos);
 405     testing::Mock::VerifyAndClearExpectations(&service);
 406     testing::Mock::VerifyAndClearExpectations(&signin);
 407     EXPECT_CALL(service, GetAuthError()).WillRepeatedly(ReturnRef(error));
 408     provider.reset();
 409     signin.Shutdown();
 410   }
 411 }