Load policy before signin completes.

chrome/browser/policy/user_policy_signin_service_unittest.cc

 // Copyright (c) 2012 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 "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/policy/mock_device_management_service.h"
@@ skipping 46 matching lines @@
     "{"
     "  \"hd\": \"test.com\""
     "}";
 
 class UserPolicySigninServiceTest : public testing::Test {
  public:
   UserPolicySigninServiceTest()
       : loop_(MessageLoop::TYPE_UI),
         ui_thread_(content::BrowserThread::UI, &loop_),
         file_thread_(content::BrowserThread::FILE, &loop_),
-        io_thread_(content::BrowserThread::IO, &loop_) {}
+        io_thread_(content::BrowserThread::IO, &loop_),
+        register_completed_(false) {}
 
   MOCK_METHOD1(OnPolicyRefresh, void(bool));
+  void OnRegisterCompleted(scoped_ptr<CloudPolicyClient> client) {
+    register_completed_ = true;
+    created_client_.swap(client);
+  }
+
+  void RegisterPolicyClientWithCallback(UserPolicySigninService* service) {
+    service->RegisterPolicyClient(
+        "testuser@test.com",
+        "mock_oauth_token",
+        base::Bind(&UserPolicySigninServiceTest::OnRegisterCompleted,
+                   base::Unretained(this)));
+    ASSERT_TRUE(IsRequestActive());
+  }
 
   virtual void SetUp() OVERRIDE {
     device_management_service_ = new MockDeviceManagementService();
     g_browser_process->browser_policy_connector()->
         SetDeviceManagementServiceForTesting(
             scoped_ptr<DeviceManagementService>(device_management_service_));
 
     g_browser_process->browser_policy_connector()->Init();
 
     local_state_.reset(new TestingPrefServiceSimple);
@@ skipping 51 matching lines @@
 
   void ReportHostedDomainStatus(bool is_hosted_domain) {
     ASSERT_TRUE(IsRequestActive());
     net::TestURLFetcher* fetcher = url_factory_.GetFetcherByID(0);
     fetcher->set_response_code(net::HTTP_OK);
     fetcher->SetResponseString(is_hosted_domain ? kHostedDomainResponse : "{}");
     fetcher->delegate()->OnURLFetchComplete(fetcher);
   }
 
   void TestSuccessfulSignin() {
-    // Set the user as signed in.
-    SigninManagerFactory::GetForProfile(profile_.get())->
-        SetAuthenticatedUsername("testuser@test.com");
-
     UserPolicySigninService* signin_service =
         UserPolicySigninServiceFactory::GetForProfile(profile_.get());
     EXPECT_CALL(*this, OnPolicyRefresh(true)).Times(0);
-    signin_service->FetchPolicyForSignedInUser(
-        "mock_token",
-        base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
-                   base::Unretained(this)));
-
-    // UserCloudPolicyManager should be initialized.
-    ASSERT_TRUE(manager_->core()->service());
-    ASSERT_TRUE(IsRequestActive());
+    RegisterPolicyClientWithCallback(signin_service);
 
     // Mimic successful oauth token fetch.
     MakeOAuthTokenFetchSucceed();
 
     // When the user is from a hosted domain, this should kick off client
     // registration.
     MockDeviceManagementJob* register_request = NULL;
     EXPECT_CALL(*device_management_service_,
                 CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION))
         .WillOnce(device_management_service_->CreateAsyncJob(
             &register_request));
     EXPECT_CALL(*device_management_service_, StartJob(_, _, _, _, _, _, _))
         .Times(1);
 
     // Now mimic the user being a hosted domain - this should cause a Register()
     // call.
     ReportHostedDomainStatus(true);
 
     // Should have no more outstanding requests.
     ASSERT_FALSE(IsRequestActive());
     Mock::VerifyAndClearExpectations(this);
     ASSERT_TRUE(register_request);
 
-    // Mimic successful client registration - this should kick off a policy
-    // fetch.
+    // Mimic successful client registration - this should register the client
+    // and invoke the callback.
+    em::DeviceManagementResponse registration_blob;
+    registration_blob.mutable_register_response()->set_device_management_token(
+        "dm_token");
+    registration_blob.mutable_register_response()->set_enrollment_type(
+        em::DeviceRegisterResponse::ENTERPRISE);
+    register_request->SendResponse(DM_STATUS_SUCCESS, registration_blob);
+
+    // UserCloudPolicyManager should not be initialized yet.
+    ASSERT_FALSE(manager_->core()->service());
+    EXPECT_TRUE(register_completed_);
+    EXPECT_TRUE(created_client_.get());
+
+    // Now call to fetch policy - this should fire off a fetch request.
     MockDeviceManagementJob* fetch_request = NULL;
     EXPECT_CALL(*device_management_service_,
                 CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH))
         .WillOnce(device_management_service_->CreateAsyncJob(&fetch_request));
     EXPECT_CALL(*device_management_service_, StartJob(_, _, _, _, _, _, _))
         .Times(1);
-    em::DeviceManagementResponse registration_blob;
-    registration_blob.mutable_register_response()->set_device_management_token(
-        "dm_token");
-    registration_blob.mutable_register_response()->set_enrollment_type(
-        em::DeviceRegisterResponse::ENTERPRISE);
-    register_request->SendResponse(DM_STATUS_SUCCESS, registration_blob);
+    signin_service->FetchPolicyForSignedInUser(
+        created_client_.Pass(),
+        base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
+                   base::Unretained(this)));
+
     Mock::VerifyAndClearExpectations(this);
     ASSERT_TRUE(fetch_request);
 
+    // UserCloudPolicyManager should now be initialized.
+    ASSERT_TRUE(manager_->core()->service());
+
     // Make the policy fetch succeed - this should result in a write to the
     // store and ultimately result in a call to OnPolicyRefresh().
     EXPECT_CALL(*mock_store_, Store(_));
     EXPECT_CALL(*this, OnPolicyRefresh(true)).Times(1);
+
     // Create a fake policy blob to deliver to the client.
     em::DeviceManagementResponse policy_blob;
     em::PolicyData policy_data;
     policy_data.set_policy_type(dm_protocol::kChromeUserPolicyType);
     em::PolicyFetchResponse* policy_response =
         policy_blob.mutable_policy_response()->add_response();
     ASSERT_TRUE(policy_data.SerializeToString(
         policy_response->mutable_policy_data()));
     fetch_request->SendResponse(DM_STATUS_SUCCESS, policy_blob);
 
@@ skipping 11 matching lines @@
 
   // BrowserPolicyConnector and UrlFetcherFactory want to initialize and free
   // various components asynchronously via tasks, so create fake threads here.
   MessageLoop loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   net::TestURLFetcherFactory url_factory_;
 
+  // Used in conjunction with OnRegisterCompleted() to test client registration
+  // callbacks.
+  scoped_ptr<CloudPolicyClient> created_client_;
+
+  // True if OnRegisterCompleted() was called.
+  bool register_completed_;
+
   // Weak ptr to the MockDeviceManagementService (object is owned by the
   // BrowserPolicyConnector).
   MockDeviceManagementService* device_management_service_;
 
   scoped_ptr<TestingPrefServiceSimple> local_state_;
 };
 
 TEST_F(UserPolicySigninServiceTest, InitWhileSignedOut) {
   EXPECT_CALL(*mock_store_, Clear());
   // Make sure user is not signed in.
@@ skipping 187 matching lines @@
   // UserCloudPolicyManager should be initialized.
   ASSERT_TRUE(manager_->core()->service());
 
   // Now sign out.
   SigninManagerFactory::GetForProfile(profile_.get())->SignOut();
 
   // UserCloudPolicyManager should be shut down.
   ASSERT_FALSE(manager_->core()->service());
 }
 
-TEST_F(UserPolicySigninServiceTest, FetchPolicyOAuthFailure) {
-  // Set the user as signed in.
-  SigninManagerFactory::GetForProfile(profile_.get())->SetAuthenticatedUsername(
-      "testuser@test.com");
-
+TEST_F(UserPolicySigninServiceTest, RegisterPolicyClientOAuthFailure) {
   UserPolicySigninService* signin_service =
       UserPolicySigninServiceFactory::GetForProfile(profile_.get());
-  EXPECT_CALL(*this, OnPolicyRefresh(_)).Times(0);
-  signin_service->FetchPolicyForSignedInUser(
-      "mock_token",
-      base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
-                 base::Unretained(this)));
+  RegisterPolicyClientWithCallback(signin_service);
   Mock::VerifyAndClearExpectations(this);
 
-  // UserCloudPolicyManager should be initialized.
-  ASSERT_TRUE(manager_->core()->service());
+  // UserCloudPolicyManager should not be initialized.
+  ASSERT_FALSE(manager_->core()->service());
   ASSERT_TRUE(IsRequestActive());
+  EXPECT_FALSE(register_completed_);
 
   // Cause the access token fetch to fail - callback should be invoked.
-  EXPECT_CALL(*this, OnPolicyRefresh(false)).Times(1);
   net::TestURLFetcher* fetcher = url_factory_.GetFetcherByID(0);
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED, -1));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_TRUE(register_completed_);
+  EXPECT_FALSE(created_client_.get());
+  EXPECT_FALSE(IsRequestActive());
 }
 
-TEST_F(UserPolicySigninServiceTest, FetchPolicyNonHostedDomain) {
-  // Set the user as signed in.
-  SigninManagerFactory::GetForProfile(profile_.get())->SetAuthenticatedUsername(
-      "testuser@test.com");
-
+TEST_F(UserPolicySigninServiceTest, RegisterPolicyClientNonHostedDomain) {
   UserPolicySigninService* signin_service =
       UserPolicySigninServiceFactory::GetForProfile(profile_.get());
-  EXPECT_CALL(*this, OnPolicyRefresh(_)).Times(0);
-  signin_service->FetchPolicyForSignedInUser(
-      "mock_token",
-      base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
-                 base::Unretained(this)));
+  RegisterPolicyClientWithCallback(signin_service);
 
-  // UserCloudPolicyManager should be initialized.
-  ASSERT_TRUE(manager_->core()->service());
+  // UserCloudPolicyManager should not be initialized.
+  ASSERT_FALSE(manager_->core()->service());
   ASSERT_TRUE(IsRequestActive());
 
   // Cause the access token request to succeed.
   MakeOAuthTokenFetchSucceed();
 
   // Should be a follow-up fetch to check the hosted-domain status.
   ASSERT_TRUE(IsRequestActive());
   Mock::VerifyAndClearExpectations(this);
+  EXPECT_FALSE(register_completed_);
 
   // Report that the user is not on a hosted domain - callback should be
   // invoked reporting a failed fetch.
-  EXPECT_CALL(*this, OnPolicyRefresh(false)).Times(1);
   ReportHostedDomainStatus(false);
 
   // Since this is not a hosted domain, we should not issue a request for a
   // DMToken.
+  EXPECT_TRUE(register_completed_);
+  EXPECT_FALSE(created_client_.get());
   ASSERT_FALSE(IsRequestActive());
 }
 
-TEST_F(UserPolicySigninServiceTest, FetchPolicyFailedRegistration) {
-  // Set the user as signed in.
-  SigninManagerFactory::GetForProfile(profile_.get())->SetAuthenticatedUsername(
-      "testuser@test.com");
-
+TEST_F(UserPolicySigninServiceTest, RegisterPolicyClientFailedRegistration) {
   UserPolicySigninService* signin_service =
       UserPolicySigninServiceFactory::GetForProfile(profile_.get());
-  EXPECT_CALL(*this, OnPolicyRefresh(true)).Times(0);
-  signin_service->FetchPolicyForSignedInUser(
-      "mock_token",
-      base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
-                 base::Unretained(this)));
+  RegisterPolicyClientWithCallback(signin_service);
 
-  // UserCloudPolicyManager should be initialized.
-  ASSERT_TRUE(manager_->core()->service());
-  ASSERT_TRUE(IsRequestActive());
+  // UserCloudPolicyManager should not be initialized.
+  ASSERT_FALSE(manager_->core()->service());
 
   // Mimic successful oauth token fetch.
   MakeOAuthTokenFetchSucceed();
+  EXPECT_FALSE(register_completed_);
 
   // When the user is from a hosted domain, this should kick off client
   // registration.
   MockDeviceManagementJob* register_request = NULL;
   EXPECT_CALL(*device_management_service_,
               CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION))
       .WillOnce(device_management_service_->CreateAsyncJob(&register_request));
   EXPECT_CALL(*device_management_service_, StartJob(_, _, _, _, _, _, _))
         .Times(1);
 
   // Now mimic the user being a hosted domain - this should cause a Register()
   // call.
   ReportHostedDomainStatus(true);
 
   // Should have no more outstanding requests.
   ASSERT_FALSE(IsRequestActive());
   Mock::VerifyAndClearExpectations(this);
   ASSERT_TRUE(register_request);
+  EXPECT_FALSE(register_completed_);
 
-  EXPECT_CALL(*this, OnPolicyRefresh(false)).Times(1);
   // Make client registration fail (hosted domain user that is not managed).
   register_request->SendResponse(DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED,
                                  em::DeviceManagementResponse());
+  EXPECT_TRUE(register_completed_);
+  EXPECT_FALSE(created_client_.get());
 }
 
-TEST_F(UserPolicySigninServiceTest, FetchPolicyPolicyFetchFailed) {
-  // Set the user as signed in.
-  SigninManagerFactory::GetForProfile(profile_.get())->SetAuthenticatedUsername(
-      "testuser@test.com");
-
+TEST_F(UserPolicySigninServiceTest, RegisterPolicyClientSucceeded) {
   UserPolicySigninService* signin_service =
       UserPolicySigninServiceFactory::GetForProfile(profile_.get());
-  EXPECT_CALL(*this, OnPolicyRefresh(true)).Times(0);
-  signin_service->FetchPolicyForSignedInUser(
-      "mock_token",
-      base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
-                 base::Unretained(this)));
-
-  // UserCloudPolicyManager should be initialized.
-  ASSERT_TRUE(manager_->core()->service());
-  ASSERT_TRUE(IsRequestActive());
+  RegisterPolicyClientWithCallback(signin_service);
 
   // Mimic successful oauth token fetch.
   MakeOAuthTokenFetchSucceed();
 
   // When the user is from a hosted domain, this should kick off client
   // registration.
   MockDeviceManagementJob* register_request = NULL;
   EXPECT_CALL(*device_management_service_,
               CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION))
       .WillOnce(device_management_service_->CreateAsyncJob(&register_request));
   EXPECT_CALL(*device_management_service_, StartJob(_, _, _, _, _, _, _))
       .Times(1);
 
   // Now mimic the user being a hosted domain - this should cause a Register()
   // call.
   ReportHostedDomainStatus(true);
 
   // Should have no more outstanding requests.
   ASSERT_FALSE(IsRequestActive());
   Mock::VerifyAndClearExpectations(this);
   ASSERT_TRUE(register_request);
+  EXPECT_FALSE(register_completed_);
 
-  // Mimic successful client registration - this should kick off a policy
-  // fetch.
-  MockDeviceManagementJob* fetch_request = NULL;
-  EXPECT_CALL(*device_management_service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH))
-      .WillOnce(device_management_service_->CreateAsyncJob(&fetch_request));
-  EXPECT_CALL(*device_management_service_, StartJob(_, _, _, _, _, _, _))
-      .Times(1);
   em::DeviceManagementResponse registration_blob;
   registration_blob.mutable_register_response()->set_device_management_token(
       "dm_token");
   registration_blob.mutable_register_response()->set_enrollment_type(
       em::DeviceRegisterResponse::ENTERPRISE);
   register_request->SendResponse(DM_STATUS_SUCCESS, registration_blob);
   Mock::VerifyAndClearExpectations(this);
+  EXPECT_TRUE(register_completed_);
+  EXPECT_TRUE(created_client_.get());
+  // UserCloudPolicyManager should not be initialized.
+  ASSERT_FALSE(manager_->core()->service());
+}
+
+TEST_F(UserPolicySigninServiceTest, FetchPolicyFailed) {
+  scoped_ptr<CloudPolicyClient> client =
+      UserCloudPolicyManager::CreateCloudPolicyClient(
+          device_management_service_);
+  client->SetupRegistration("mock_dm_token", "mock_client_id");
+
+  // Initiate a policy fetch request.
+  MockDeviceManagementJob* fetch_request = NULL;
+  EXPECT_CALL(*device_management_service_,
+              CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH))
+      .WillOnce(device_management_service_->CreateAsyncJob(&fetch_request));
+  EXPECT_CALL(*device_management_service_, StartJob(_, _, _, _, _, _, _))
+      .Times(1);
+  UserPolicySigninService* signin_service =
+      UserPolicySigninServiceFactory::GetForProfile(profile_.get());
+  signin_service->FetchPolicyForSignedInUser(
+      client.Pass(),
+      base::Bind(&UserPolicySigninServiceTest::OnPolicyRefresh,
+                 base::Unretained(this)));
   ASSERT_TRUE(fetch_request);
 
   // Make the policy fetch fail.
   EXPECT_CALL(*this, OnPolicyRefresh(false)).Times(1);
   fetch_request->SendResponse(DM_STATUS_REQUEST_FAILED,
                               em::DeviceManagementResponse());
+  // UserCloudPolicyManager should be initialized.
+  ASSERT_TRUE(manager_->core()->service());
 }
 
 TEST_F(UserPolicySigninServiceTest, FetchPolicySuccess) {
   TestSuccessfulSignin();
 }
 
 TEST_F(UserPolicySigninServiceTest, SignOutThenSignInAgain) {
   TestSuccessfulSignin();
 
   // Now sign out.
   SigninManagerFactory::GetForProfile(profile_.get())->SignOut();
   ASSERT_FALSE(manager_->core()->service());
 
   // Now sign in again.
   TestSuccessfulSignin();
 }
 
 }  // namespace
 
 }  // namespace policy