Cleanup mock device management backend

chrome/browser/policy/device_token_fetcher_unittest.cc

 // Copyright (c) 2010 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 <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 72 matching lines @@
   ScopedTempDir temp_user_data_dir_;
   scoped_refptr<DeviceTokenFetcher> fetcher_;
 
  private:
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
 };
 
 TEST_F(DeviceTokenFetcherTest, IsPending) {
   ASSERT_TRUE(fetcher_->IsTokenPending());
-  backend_->AllShouldSucceed();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      SucceedRegister());
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
 }
 
 TEST_F(DeviceTokenFetcherTest, StoreAndLoad) {
-  backend_->AllShouldSucceed();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      SucceedRegister());
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   std::string device_token = fetcher_->GetDeviceToken();
   std::string device_id = fetcher_->GetDeviceID();
   ASSERT_NE("", device_id);
 
   FilePath token_path;
   GetDeviceTokenPath(fetcher_, &token_path);
   scoped_refptr<DeviceTokenFetcher> fetcher2(
       new DeviceTokenFetcher(backend_.get(), token_service_.get(), token_path));
   fetcher2->StartFetching();
   loop_.RunAllPending();
   ASSERT_EQ(device_id, fetcher2->GetDeviceID());
   ASSERT_EQ(device_token, fetcher2->GetDeviceToken());
 }
 
 TEST_F(DeviceTokenFetcherTest, SimpleFetchSingleLogin) {
-  backend_->AllShouldSucceed();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      SucceedRegister());
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   ASSERT_TRUE(fetcher_->IsTokenValid());
   const std::string token(fetcher_->GetDeviceToken());
   EXPECT_NE("", token);
 }
 
 TEST_F(DeviceTokenFetcherTest, SimpleFetchDoubleLogin) {
-  backend_->AllShouldSucceed();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      SucceedRegister());
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   const std::string token(fetcher_->GetDeviceToken());
   EXPECT_NE("", token);
 
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   const std::string token2(fetcher_->GetDeviceToken());
   EXPECT_NE("", token2);
   EXPECT_EQ(token, token2);
 }
 
 TEST_F(DeviceTokenFetcherTest, FetchBetweenBrowserLaunchAndNotify) {
   MockTokenAvailableObserver observer;
   DeviceTokenFetcher::ObserverRegistrar registrar;
   registrar.Init(fetcher_);
   registrar.AddObserver(&observer);
   EXPECT_CALL(observer, OnTokenSuccess()).Times(1);
   EXPECT_CALL(observer, OnTokenError()).Times(0);
-  backend_->AllShouldSucceed();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      SucceedRegister());
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   const std::string token(fetcher_->GetDeviceToken());
   EXPECT_NE("", token);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Swap out the fetchers, including copying the device management token on
   // disk to where the new fetcher expects it.
   registrar.RemoveAll();
   fetcher_ = NewTestFetcher(temp_user_data_dir_.path());
   registrar.Init(fetcher_);
   fetcher_->StartFetching();
   ASSERT_TRUE(fetcher_->IsTokenPending());
   loop_.RunAllPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   const std::string token2(fetcher_->GetDeviceToken());
   EXPECT_NE("", token2);
   EXPECT_EQ(token, token2);
 }
 
 TEST_F(DeviceTokenFetcherTest, FailedServerRequest) {
   MockTokenAvailableObserver observer;
   DeviceTokenFetcher::ObserverRegistrar registrar;
   registrar.Init(fetcher_);
   registrar.AddObserver(&observer);
   EXPECT_CALL(observer, OnTokenSuccess()).Times(0);
   EXPECT_CALL(observer, OnTokenError()).Times(1);
-  backend_->AllShouldFail();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      FailRegister(DeviceManagementBackend::kErrorRequestFailed));
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   const std::string token(fetcher_->GetDeviceToken());
   EXPECT_EQ("", token);
 }
 
 TEST_F(DeviceTokenFetcherTest, UnmanagedDevice) {
   FilePath token_path;
   GetDeviceTokenPath(fetcher_, &token_path);
   file_util::WriteFile(token_path, "foo", 3);
   ASSERT_TRUE(file_util::PathExists(token_path));
-  backend_->UnmanagedDevice();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      FailRegister(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   ASSERT_EQ("", fetcher_->GetDeviceToken());
   ASSERT_EQ("", device_id(fetcher_));
   ASSERT_FALSE(file_util::PathExists(token_path));
 }
 
 }  // namespace policy