Switch to id-based affiliation determination

chrome/browser/chromeos/policy/affiliated_invalidation_service_provider_impl_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/policy/affiliated_invalidation_service_provider_impl.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 69 matching lines @@
 };
 
 class AffiliatedInvalidationServiceProviderImplTest : public testing::Test {
  public:
   AffiliatedInvalidationServiceProviderImplTest();
 
   // testing::Test:
   void SetUp() override;
   void TearDown() override;
 
-  // Ownership is not passed. The Profile is owned by the global ProfileManager.
-  Profile* LogInAndReturnProfile(const std::string& user_id);
+  // Both functions don't pass ownership of the profile. The Profile is owned
+  // by the global ProfileManager.
+  Profile* LogInAndReturnAffiliatedProfile(const std::string& user_id);
+  Profile* LogInAndReturnNonAffiliatedProfile(const std::string& user_id);
 
   // Logs in as an affiliated user and indicates that the per-profile
   // invalidation service for this user connected. Verifies that this
   // invalidation service is made available to the |consumer_| and the
   // device-global invalidation service is destroyed.
   void LogInAsAffiliatedUserAndConnectInvalidationService();
 
   // Logs in as an unaffiliated user and indicates that the per-profile
   // invalidation service for this user connected. Verifies that this
   // invalidation service is ignored and the device-global invalidation service
   // is not destroyed.
   void LogInAsUnaffiliatedUserAndConnectInvalidationService();
 
   // Indicates that the device-global invalidation service connected. Verifies
   // that the |consumer_| is informed about this.
   void ConnectDeviceGlobalInvalidationService();
 
   // Indicates that the logged-in user's per-profile invalidation service
   // disconnected. Verifies that the |consumer_| is informed about this and a
   // device-global invalidation service is created.
   void DisconnectPerProfileInvalidationService();
 
   invalidation::FakeInvalidationService* GetProfileInvalidationService(
       Profile* profile,
       bool create);
 
  protected:
+  // Ownership is not passed. The Profile is owned by the global ProfileManager.
+  Profile* LogInAndReturnProfile(const std::string& user_id,
+                                 bool is_affiliated);
   scoped_ptr<AffiliatedInvalidationServiceProviderImpl> provider_;
   scoped_ptr<FakeConsumer> consumer_;
   invalidation::TiclInvalidationService* device_invalidation_service_;
   invalidation::FakeInvalidationService* profile_invalidation_service_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   chromeos::FakeChromeUserManager* fake_user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   ScopedStubEnterpriseInstallAttributes install_attributes_;
@@ skipping 84 matching lines @@
   provider_->Shutdown();
   provider_.reset();
 
   invalidation::ProfileInvalidationProviderFactory::GetInstance()->
       RegisterTestingFactory(nullptr);
   chromeos::DeviceOAuth2TokenServiceFactory::Shutdown();
   chromeos::DBusThreadManager::Shutdown();
   chromeos::SystemSaltGetter::Shutdown();
 }
 
+Profile*
+AffiliatedInvalidationServiceProviderImplTest::LogInAndReturnAffiliatedProfile(
+    const std::string& user_id) {
+  return LogInAndReturnProfile(user_id, true);
+}
+
+Profile* AffiliatedInvalidationServiceProviderImplTest::
+    LogInAndReturnNonAffiliatedProfile(const std::string& user_id) {
+  return LogInAndReturnProfile(user_id, false);
+}
+
 Profile* AffiliatedInvalidationServiceProviderImplTest::LogInAndReturnProfile(
-    const std::string& user_id) {
-  fake_user_manager_->AddUser(AccountId::FromUserEmail(user_id));
+    const std::string& user_id,
+    bool is_affiliated) {
+  fake_user_manager_->AddUserWithAffiliation(AccountId::FromUserEmail(user_id),
+                                             is_affiliated);
   Profile* profile = profile_manager_.CreateTestingProfile(user_id);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile));
   return profile;
 }
 
 void AffiliatedInvalidationServiceProviderImplTest::
     LogInAsAffiliatedUserAndConnectInvalidationService() {
   // Log in as an affiliated user.
-  Profile* profile = LogInAndReturnProfile(kAffiliatedUserID1);
+  Profile* profile = LogInAndReturnAffiliatedProfile(kAffiliatedUserID1);
   EXPECT_TRUE(profile);
 
   // Verify that a per-profile invalidation service has been created.
   profile_invalidation_service_ =
       GetProfileInvalidationService(profile, false /* create */);
   ASSERT_TRUE(profile_invalidation_service_);
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Indicate that the per-profile invalidation service has connected. Verify
   // that the consumer is informed about this.
   EXPECT_EQ(0, consumer_->GetAndClearInvalidationServiceSetCount());
   profile_invalidation_service_->SetInvalidatorState(
       syncer::INVALIDATIONS_ENABLED);
   EXPECT_EQ(1, consumer_->GetAndClearInvalidationServiceSetCount());
   EXPECT_EQ(profile_invalidation_service_, consumer_->GetInvalidationService());
 
   // Verify that the device-global invalidation service has been destroyed.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 }
 
 void AffiliatedInvalidationServiceProviderImplTest::
     LogInAsUnaffiliatedUserAndConnectInvalidationService() {
   // Log in as an unaffiliated user.
-  Profile* profile = LogInAndReturnProfile(kUnaffiliatedUserID);
+  Profile* profile = LogInAndReturnNonAffiliatedProfile(kUnaffiliatedUserID);
   EXPECT_TRUE(profile);
 
   // Verify that a per-profile invalidation service has been created.
   profile_invalidation_service_ =
       GetProfileInvalidationService(profile, false /* create */);
   ASSERT_TRUE(profile_invalidation_service_);
 
   // Verify that the device-global invalidation service still exists.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
@@ skipping 54 matching lines @@
 
 // No consumers are registered with the
 // AffiliatedInvalidationServiceProviderImpl. Verifies that no device-global
 // invalidation service is created, whether an affiliated user is logged in or
 // not.
 TEST_F(AffiliatedInvalidationServiceProviderImplTest, NoConsumers) {
   // Verify that no device-global invalidation service has been created.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as an affiliated user.
-  EXPECT_TRUE(LogInAndReturnProfile(kAffiliatedUserID1));
+  EXPECT_TRUE(LogInAndReturnAffiliatedProfile(kAffiliatedUserID1));
 
   // Verify that no device-global invalidation service has been created.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 }
 
 // Verifies that when no connected invalidation service is available for use,
 // none is made available to consumers.
 TEST_F(AffiliatedInvalidationServiceProviderImplTest,
        NoInvalidationServiceAvailable) {
   // Register a consumer. Verify that the consumer is not called back
@@ skipping 150 matching lines @@
   // Verify that a device-global invalidation service has been created.
   EXPECT_TRUE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as a first affiliated user and indicate that the per-profile
   // invalidation service for this user connected. Verify that this invalidation
   // service is made available to the |consumer_| and the device-global
   // invalidation service is destroyed.
   LogInAsAffiliatedUserAndConnectInvalidationService();
 
   // Log in as a second affiliated user.
-  Profile* second_profile = LogInAndReturnProfile(kAffiliatedUserID2);
+  Profile* second_profile = LogInAndReturnAffiliatedProfile(kAffiliatedUserID2);
   EXPECT_TRUE(second_profile);
 
   // Verify that the device-global invalidation service still does not exist.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Verify that a per-profile invalidation service for the second user has been
   // created.
   invalidation::FakeInvalidationService* second_profile_invalidation_service =
       GetProfileInvalidationService(second_profile, false /* create */);
   ASSERT_TRUE(second_profile_invalidation_service);
@@ skipping 78 matching lines @@
   // invalidation service is available for use anymore.
   EXPECT_EQ(0, consumer_->GetAndClearInvalidationServiceSetCount());
   provider_->Shutdown();
   EXPECT_EQ(1, consumer_->GetAndClearInvalidationServiceSetCount());
   EXPECT_EQ(nullptr, consumer_->GetInvalidationService());
 
   // Verify that the device-global invalidation service still does not exist.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Log in as a second affiliated user.
-  Profile* second_profile = LogInAndReturnProfile(kAffiliatedUserID2);
+  Profile* second_profile = LogInAndReturnAffiliatedProfile(kAffiliatedUserID2);
   EXPECT_TRUE(second_profile);
 
   // Verify that the device-global invalidation service still does not exist.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 
   // Create a per-profile invalidation service for the second user.
   invalidation::FakeInvalidationService* second_profile_invalidation_service =
       GetProfileInvalidationService(second_profile, true /* create */);
   ASSERT_TRUE(second_profile_invalidation_service);
 
@@ skipping 33 matching lines @@
   EXPECT_EQ(0, consumer_->GetAndClearInvalidationServiceSetCount());
   provider_->Shutdown();
   EXPECT_EQ(1, consumer_->GetAndClearInvalidationServiceSetCount());
   EXPECT_EQ(nullptr, consumer_->GetInvalidationService());
 
   // Verify that the device-global invalidation service has been destroyed.
   EXPECT_FALSE(provider_->GetDeviceInvalidationServiceForTest());
 }
 
 }  // namespace policy