src/chrome/android/javatests/src/org/chromium/chrome/browser/signin/OAuth2TokenServiceIntegrationTest.java

   1 // Copyright 2013 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 package org.chromium.chrome.browser.signin;
   6
   7 import android.accounts.Account;
   8 import android.test.UiThreadTest;
   9 import android.test.suitebuilder.annotation.MediumTest;
  10
  11 import org.chromium.base.ThreadUtils;
  12 import org.chromium.base.test.util.AdvancedMockContext;
  13 import org.chromium.base.test.util.Feature;
  14 import org.chromium.chrome.browser.profiles.Profile;
  15 import org.chromium.chrome.shell.ChromeShellTestBase;
  16 import org.chromium.sync.signin.AccountManagerHelper;
  17 import org.chromium.sync.signin.ChromeSigninController;
  18 import org.chromium.sync.test.util.AccountHolder;
  19 import org.chromium.sync.test.util.MockAccountManager;
  20
  21 import java.util.concurrent.atomic.AtomicReference;
  22
  23 /**
  24  * Integration test for the OAuth2TokenService.
  25  *
  26  * These tests initialize the native part of the service.
  27  */
  28 public class OAuth2TokenServiceIntegrationTest extends ChromeShellTestBase {
  29
  30     private static final Account TEST_ACCOUNT1 =
  31             AccountManagerHelper.createAccountFromName("foo@gmail.com");
  32     private static final Account TEST_ACCOUNT2 =
  33             AccountManagerHelper.createAccountFromName("bar@gmail.com");
  34     private static final AccountHolder TEST_ACCOUNT_HOLDER_1 =
  35             AccountHolder.create().account(TEST_ACCOUNT1).alwaysAccept(true).build();
  36     private static final AccountHolder TEST_ACCOUNT_HOLDER_2 =
  37             AccountHolder.create().account(TEST_ACCOUNT2).alwaysAccept(true).build();
  38
  39     private AdvancedMockContext mContext;
  40     private OAuth2TokenService mOAuth2TokenService;
  41     private MockAccountManager mAccountManager;
  42     private TestObserver mObserver;
  43     private ChromeSigninController mChromeSigninController;
  44
  45     @Override
  46     protected void setUp() throws Exception {
  47         super.setUp();
  48         clearAppData();
  49         startChromeBrowserProcessSync(getInstrumentation().getTargetContext());
  50
  51         // Set up AccountManager.
  52         mContext = new AdvancedMockContext(getInstrumentation().getTargetContext());
  53         mAccountManager = new MockAccountManager(mContext, getInstrumentation().getContext());
  54         AccountManagerHelper.overrideAccountManagerHelperForTests(mContext, mAccountManager);
  55
  56         // Make sure there is no account signed in yet.
  57         mChromeSigninController = ChromeSigninController.get(mContext);
  58         mChromeSigninController.setSignedInAccountName(null);
  59
  60         // Get a reference to the service.
  61         mOAuth2TokenService = getOAuth2TokenServiceOnUiThread();
  62
  63         // Set up observer.
  64         mObserver = new TestObserver();
  65         addObserver(mObserver);
  66     }
  67
  68     /**
  69      * The {@link OAuth2TokenService} and the {@link Profile} can only be accessed from the UI
  70      * thread, so this helper method is a convenience method to retrieve it.
  71      *
  72      * @return the OAuth2TokenService.
  73      */
  74     private static OAuth2TokenService getOAuth2TokenServiceOnUiThread() {
  75         final AtomicReference<OAuth2TokenService> service =
  76                 new AtomicReference<OAuth2TokenService>();
  77         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
  78             @Override
  79             public void run() {
  80                 service.set(OAuth2TokenService.getForProfile(Profile.getLastUsedProfile()));
  81             }
  82         });
  83         return service.get();
  84     }
  85
  86     private void addObserver(final TestObserver observer) {
  87         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
  88             @Override
  89             public void run() {
  90                 mOAuth2TokenService.addObserver(observer);
  91             }
  92         });
  93     }
  94
  95     @MediumTest
  96     @UiThreadTest
  97     @Feature({"Sync"})
  98     public void testFireRefreshTokenAvailableNotifiesJavaObservers() {
  99         // Adding an observer should not lead to a callback.
 100         assertEquals(0, mObserver.getAvailableCallCount());
 101
 102         // An observer should be called with the correct account.
 103         mOAuth2TokenService.fireRefreshTokenAvailable(TEST_ACCOUNT1);
 104         assertEquals(1, mObserver.getAvailableCallCount());
 105         assertEquals(TEST_ACCOUNT1, mObserver.getLastAccount());
 106
 107         // When mOAuth2TokenService, an observer should not be called.
 108         mOAuth2TokenService.removeObserver(mObserver);
 109         mOAuth2TokenService.fireRefreshTokenAvailable(TEST_ACCOUNT1);
 110         assertEquals(1, mObserver.getAvailableCallCount());
 111
 112         // No other observer interface method should ever have been called.
 113         assertEquals(0, mObserver.getRevokedCallCount());
 114         assertEquals(0, mObserver.getLoadedCallCount());
 115     }
 116
 117     @MediumTest
 118     @UiThreadTest
 119     @Feature({"Sync"})
 120     public void testFireRefreshTokenRevokedNotifiesJavaObservers() {
 121         // Adding an observer should not lead to a callback.
 122         assertEquals(0, mObserver.getRevokedCallCount());
 123
 124         // An observer should be called with the correct account.
 125         mOAuth2TokenService.fireRefreshTokenRevoked(TEST_ACCOUNT1);
 126         assertEquals(1, mObserver.getRevokedCallCount());
 127         assertEquals(TEST_ACCOUNT1, mObserver.getLastAccount());
 128
 129         // When removed, an observer should not be called.
 130         mOAuth2TokenService.removeObserver(mObserver);
 131         mOAuth2TokenService.fireRefreshTokenRevoked(TEST_ACCOUNT1);
 132         assertEquals(1, mObserver.getRevokedCallCount());
 133
 134         // No other observer interface method should ever have been called.
 135         assertEquals(0, mObserver.getAvailableCallCount());
 136         assertEquals(0, mObserver.getLoadedCallCount());
 137     }
 138
 139     @MediumTest
 140     @UiThreadTest
 141     @Feature({"Sync"})
 142     public void testFireRefreshTokensLoadedNotifiesJavaObservers() {
 143         // Adding an observer should not lead to a callback.
 144         assertEquals(0, mObserver.getLoadedCallCount());
 145
 146         // An observer should be called with the correct account.
 147         mOAuth2TokenService.fireRefreshTokensLoaded();
 148         assertEquals(1, mObserver.getLoadedCallCount());
 149
 150         // When removed, an observer should not be called.
 151         mOAuth2TokenService.removeObserver(mObserver);
 152         mOAuth2TokenService.fireRefreshTokensLoaded();
 153         assertEquals(1, mObserver.getLoadedCallCount());
 154
 155         // No other observer interface method should ever have been called.
 156         assertEquals(0, mObserver.getAvailableCallCount());
 157         assertEquals(0, mObserver.getRevokedCallCount());
 158     }
 159
 160     @MediumTest
 161     @UiThreadTest
 162     public void testValidateAccountsNoAccountsRegisteredAndNoSignedInUser() {
 163         // Run test.
 164         mOAuth2TokenService.validateAccounts(mContext, false);
 165
 166         // Ensure no calls have been made to the observer.
 167         assertEquals(0, mObserver.getAvailableCallCount());
 168         assertEquals(0, mObserver.getRevokedCallCount());
 169         assertEquals(0, mObserver.getLoadedCallCount());
 170     }
 171
 172     @MediumTest
 173     @UiThreadTest
 174     public void testValidateAccountsOneAccountsRegisteredAndNoSignedInUser() {
 175         // Add account.
 176         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 177
 178         // Run test.
 179         mOAuth2TokenService.validateAccounts(mContext, false);
 180
 181         // Ensure no calls have been made to the observer.
 182         assertEquals(0, mObserver.getAvailableCallCount());
 183         assertEquals(0, mObserver.getRevokedCallCount());
 184         assertEquals(0, mObserver.getLoadedCallCount());
 185     }
 186
 187     @MediumTest
 188     @UiThreadTest
 189     public void testValidateAccountsOneAccountsRegisteredSignedIn() {
 190         // Add account.
 191         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 192
 193         // Mark user as signed in.
 194         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 195
 196         // Run test.
 197         mOAuth2TokenService.validateAccounts(mContext, false);
 198
 199         // Ensure one call for the signed in account.
 200         assertEquals(1, mObserver.getAvailableCallCount());
 201         assertEquals(0, mObserver.getRevokedCallCount());
 202         assertEquals(0, mObserver.getLoadedCallCount());
 203
 204         // Validate again and make sure no new calls are made.
 205         mOAuth2TokenService.validateAccounts(mContext, false);
 206         assertEquals(1, mObserver.getAvailableCallCount());
 207         assertEquals(0, mObserver.getRevokedCallCount());
 208         assertEquals(0, mObserver.getLoadedCallCount());
 209
 210         // Validate again with force notifications and make sure one new calls is made.
 211         mOAuth2TokenService.validateAccounts(mContext, true);
 212         assertEquals(2, mObserver.getAvailableCallCount());
 213         assertEquals(0, mObserver.getRevokedCallCount());
 214         assertEquals(0, mObserver.getLoadedCallCount());
 215     }
 216
 217     @MediumTest
 218     @UiThreadTest
 219     public void testValidateAccountsSingleAccountWithoutChanges() {
 220         // Add account.
 221         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 222
 223         // Mark user as signed in.
 224         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 225
 226         // Run one validation.
 227         mOAuth2TokenService.validateAccounts(mContext, false);
 228         assertEquals(1, mObserver.getAvailableCallCount());
 229         assertEquals(0, mObserver.getRevokedCallCount());
 230         assertEquals(0, mObserver.getLoadedCallCount());
 231
 232         // Re-run validation.
 233         mOAuth2TokenService.validateAccounts(mContext, false);
 234         assertEquals(1, mObserver.getAvailableCallCount());
 235         assertEquals(0, mObserver.getRevokedCallCount());
 236         assertEquals(0, mObserver.getLoadedCallCount());
 237     }
 238
 239     @MediumTest
 240     @UiThreadTest
 241     public void testValidateAccountsSingleAccountThenAddOne() {
 242         // Add account.
 243         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 244
 245         // Mark user as signed in.
 246         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 247
 248         // Run one validation.
 249         mOAuth2TokenService.validateAccounts(mContext, false);
 250         assertEquals(1, mObserver.getAvailableCallCount());
 251         assertEquals(0, mObserver.getRevokedCallCount());
 252         assertEquals(0, mObserver.getLoadedCallCount());
 253
 254         // Add another account.
 255         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 256
 257         // Re-run validation.
 258         mOAuth2TokenService.validateAccounts(mContext, false);
 259         assertEquals(2, mObserver.getAvailableCallCount());
 260         assertEquals(0, mObserver.getRevokedCallCount());
 261         assertEquals(0, mObserver.getLoadedCallCount());
 262     }
 263
 264     @MediumTest
 265     @UiThreadTest
 266     public void testValidateAccountsTwoAccountsThenRemoveOne() {
 267         // Add accounts.
 268         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 269         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 270
 271         // Mark user as signed in.
 272         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 273
 274         // Run one validation.
 275         mOAuth2TokenService.validateAccounts(mContext, false);
 276         assertEquals(2, mObserver.getAvailableCallCount());
 277
 278         mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 279         mOAuth2TokenService.validateAccounts(mContext, false);
 280
 281         assertEquals(2, mObserver.getAvailableCallCount());
 282         assertEquals(1, mObserver.getRevokedCallCount());
 283         assertEquals(0, mObserver.getLoadedCallCount());
 284     }
 285
 286     @MediumTest
 287     @UiThreadTest
 288     public void testValidateAccountsTwoAccountsThenRemoveAll() {
 289         // Add accounts.
 290         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 291         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 292
 293         // Mark user as signed in.
 294         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 295
 296         mOAuth2TokenService.validateAccounts(mContext, false);
 297         assertEquals(2, mObserver.getAvailableCallCount());
 298
 299         // Remove all.
 300         mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 301         mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 302
 303         // Re-validate and run checks.
 304         mOAuth2TokenService.validateAccounts(mContext, false);
 305         assertEquals(2, mObserver.getRevokedCallCount());
 306         assertEquals(0, mObserver.getLoadedCallCount());
 307     }
 308
 309     @MediumTest
 310     @UiThreadTest
 311     public void testValidateAccountsTwoAccountsThenRemoveAllSignOut() {
 312         // Add accounts.
 313         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 314         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 315
 316         // Mark user as signed in.
 317         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 318
 319         mOAuth2TokenService.validateAccounts(mContext, false);
 320         assertEquals(2, mObserver.getAvailableCallCount());
 321
 322         // Remove all.
 323         mChromeSigninController.clearSignedInUser();
 324         mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 325         mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 326
 327         // Re-validate and run checks.
 328         mOAuth2TokenService.validateAccounts(mContext, false);
 329         assertEquals(2, mObserver.getRevokedCallCount());
 330         assertEquals(0, mObserver.getLoadedCallCount());
 331     }
 332
 333     @MediumTest
 334     @UiThreadTest
 335     public void testValidateAccountsTwoAccountsRegisteredAndOneSignedIn() {
 336         // Add accounts.
 337         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 338         mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 339
 340         // Mark user as signed in.
 341         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 342
 343         // Run test.
 344         mOAuth2TokenService.validateAccounts(mContext, false);
 345
 346         // All accounts will be notified. It is up to the observer
 347         // to design if any action is needed.
 348         assertEquals(2, mObserver.getAvailableCallCount());
 349         assertEquals(0, mObserver.getRevokedCallCount());
 350         assertEquals(0, mObserver.getLoadedCallCount());
 351     }
 352
 353     @MediumTest
 354     @UiThreadTest
 355     public void testValidateAccountsNoAccountsRegisteredButSignedIn() {
 356         // Mark user as signed in without setting up the account.
 357         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 358
 359         // Run test.
 360         mOAuth2TokenService.validateAccounts(mContext, false);
 361
 362         // Ensure no calls have been made to the observer.
 363         assertEquals(0, mObserver.getAvailableCallCount());
 364         assertEquals(0, mObserver.getRevokedCallCount());
 365         assertEquals(0, mObserver.getLoadedCallCount());
 366     }
 367
 368     @MediumTest
 369     @UiThreadTest
 370     public void testValidateAccountsFiresEventAtTheEnd() {
 371         // Mark user as signed in without setting up the account.
 372         mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 373         TestObserver ob = new TestObserver() {
 374             @Override
 375             public void onRefreshTokenAvailable(Account account) {
 376                 super.onRefreshTokenAvailable(account);
 377                 assertEquals(1, OAuth2TokenService.getAccounts(mContext).length);
 378             }
 379         };
 380
 381         addObserver(ob);
 382         mOAuth2TokenService.validateAccounts(mContext, false);
 383     }
 384
 385     private static class TestObserver implements OAuth2TokenService.OAuth2TokenServiceObserver {
 386         private int mAvailableCallCount;
 387         private int mRevokedCallCount;
 388         private int mLoadedCallCount;
 389         private Account mLastAccount;
 390
 391         @Override
 392         public void onRefreshTokenAvailable(Account account) {
 393             mAvailableCallCount++;
 394             mLastAccount = account;
 395         }
 396
 397         @Override
 398         public void onRefreshTokenRevoked(Account account) {
 399             mRevokedCallCount++;
 400             mLastAccount = account;
 401         }
 402
 403         @Override
 404         public void onRefreshTokensLoaded() {
 405             mLoadedCallCount++;
 406         }
 407
 408         public int getAvailableCallCount() {
 409             return mAvailableCallCount;
 410         }
 411
 412         public int getRevokedCallCount() {
 413             return mRevokedCallCount;
 414         }
 415
 416         public int getLoadedCallCount() {
 417             return mLoadedCallCount;
 418         }
 419
 420         public Account getLastAccount() {
 421             return mLastAccount;
 422         }
 423     }
 424 }