Refresh policies from DM server periodically

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"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/policy/device_token_fetcher.h"
 #include "chrome/browser/policy/mock_device_management_backend.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 const char kTestToken[] = "device_token_fetcher_test_auth_token";
 
 using testing::_;
 using testing::Mock;
 
-class MockTokenAvailableObserver : public NotificationObserver {
+class MockTokenAvailableObserver : public DeviceTokenFetcher::Observer {
  public:
   MockTokenAvailableObserver() {}
   virtual ~MockTokenAvailableObserver() {}
 
-  MOCK_METHOD3(Observe, void(
-      NotificationType type,
-      const NotificationSource& source,
-      const NotificationDetails& details));
+  MOCK_METHOD0(OnTokenSuccess, void());
+  MOCK_METHOD0(OnTokenError, void());
+  MOCK_METHOD0(OnNotManaged, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockTokenAvailableObserver);
 };
 
 class DeviceTokenFetcherTest : public testing::Test {
  protected:
   DeviceTokenFetcherTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {
@@ skipping 90 matching lines @@
   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) {
-  NotificationRegistrar registrar;
   MockTokenAvailableObserver observer;
-  registrar.Add(&observer,
-                NotificationType::DEVICE_TOKEN_AVAILABLE,
-                NotificationService::AllSources());
-  EXPECT_CALL(observer, Observe(_, _, _)).Times(1);
+  scoped_ptr<DeviceTokenFetcher::ObserverRegistrar> registrar(
+      new DeviceTokenFetcher::ObserverRegistrar(fetcher_));
+  registrar->AddObserver(&observer);
+  EXPECT_CALL(observer, OnTokenSuccess()).Times(1);
+  EXPECT_CALL(observer, OnTokenError()).Times(0);
   backend_->AllShouldSucceed();
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
   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.
-  fetcher_ = NewTestFetcher(
-      temp_user_data_dir_.path());
+  registrar.reset(NULL);

[danno, 2010/11/23 12:10:14]

Aternitavely, you can add a RemoveObserver method to the registrar, which you
can call here. That way the registrar doesn't have to be a scoped_ptr.

[Jakob Kummerow (corp), 2010/11/23 12:25:26]

That's the alternative, yes. It would mean more code. Would you find that
better, or are you just providing ideas for discussion again? ;-)

+  fetcher_ = NewTestFetcher(temp_user_data_dir_.path());
+  registrar.reset(new DeviceTokenFetcher::ObserverRegistrar(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(fetcher_);
+  registrar.AddObserver(&observer);
+  EXPECT_CALL(observer, OnTokenSuccess()).Times(0);
+  EXPECT_CALL(observer, OnTokenError()).Times(1);
   backend_->AllShouldFail();
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).Times(1);
   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);
   SimulateSuccessfulLoginAndRunPending();
   ASSERT_FALSE(fetcher_->IsTokenPending());
   ASSERT_EQ("", fetcher_->GetDeviceToken());
   ASSERT_EQ("", device_id(fetcher_));
-  FilePath token_path;
-  GetDeviceTokenPath(fetcher_, &token_path);
   ASSERT_FALSE(file_util::PathExists(token_path));
 }
 
 }  // namespace policy