Rework the device management backend implementation.

chrome/browser/policy/device_management_backend_impl_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 "chrome/browser/policy/device_management_backend_impl.h"
 
 #include "base/message_loop.h"
 #include "base/string_split.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/policy/device_management_backend_mock.h"
@@ skipping 22 matching lines @@
 
 }  // namespace
 
 // Unit tests for the google apps policy backend. The pattern here is each test
 // case triggeres a request and installs a mock delegate. The test will run and
 // the default action installed on the test delegate will quit the loop.
 template<typename TESTBASE>
 class DeviceManagementBackendImplTestBase : public TESTBASE {
  protected:
   DeviceManagementBackendImplTestBase()
-      : io_thread_(BrowserThread::IO, &loop_),
-        service_(kServiceURL) {}
+      : io_thread_(BrowserThread::IO, &loop_) {
+    ResetBackend();
+    service_.reset(backend_->Get());
+  }
 
   virtual void SetUp() {
     URLFetcher::set_factory(&factory_);
   }
 
   virtual void TearDown() {
     URLFetcher::set_factory(NULL);
+    service_.reset();
+    backend_.reset();
     loop_.RunAllPending();
   }
 
+  void ResetBackend() {
+    backend_.reset(new DeviceManagementBackendImpl(kServiceURL, NULL));
+  }
+
+  TestURLFetcherFactory factory_;
+  scoped_ptr<DeviceManagementBackendImpl> backend_;
+  scoped_ptr<DeviceManagementBackend> service_;
+
+ private:
   MessageLoopForUI loop_;
   BrowserThread io_thread_;
-  TestURLFetcherFactory factory_;
-  DeviceManagementBackendImpl service_;
 };
 
 struct FailedRequestParams {
   FailedRequestParams(DeviceManagementBackend::ErrorCode expected_error,
                       URLRequestStatus::Status request_status,
                       int http_status,
                       const std::string& response)
       : expected_error_(expected_error),
         request_status_(request_status, 0),
         http_status_(http_status),
         response_(response) {}
 
   DeviceManagementBackend::ErrorCode expected_error_;
   URLRequestStatus request_status_;
   int http_status_;
   std::string response_;
 };
 
 // A parameterized test case for erroneous response situations, they're mostly
 // the same for all kinds of requests.
 class DeviceManagementBackendImplFailedRequestTest
     : public DeviceManagementBackendImplTestBase<
           testing::TestWithParam<FailedRequestParams> > {
 };
 
 TEST_P(DeviceManagementBackendImplFailedRequestTest, RegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DeviceRegisterRequest request;
-  service_.ProcessRegisterRequest("token", "device id", request, &mock);
+  service_->ProcessRegisterRequest("token", "device id", request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceURL),
                                           GetParam().request_status_,
                                           GetParam().http_status_,
                                           ResponseCookies(),
                                           GetParam().response_);
 }
 
 TEST_P(DeviceManagementBackendImplFailedRequestTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DeviceUnregisterRequest request;
-  service_.ProcessUnregisterRequest("token", request, &mock);
+  service_->ProcessUnregisterRequest("token", request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceURL),
                                           GetParam().request_status_,
                                           GetParam().http_status_,
                                           ResponseCookies(),
                                           GetParam().response_);
 }
 
 TEST_P(DeviceManagementBackendImplFailedRequestTest, PolicyRequest) {
   DevicePolicyResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DevicePolicyRequest request;
   request.set_policy_scope("Chrome");
   em::DevicePolicySettingRequest* setting_request =
       request.add_setting_request();
   setting_request->set_key("policy");
-  service_.ProcessPolicyRequest("token", request, &mock);
+  service_->ProcessPolicyRequest("token", request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceURL),
                                           GetParam().request_status_,
                                           GetParam().http_status_,
                                           ResponseCookies(),
                                           GetParam().response_);
 }
@@ skipping 89 matching lines @@
   typedef std::vector<std::pair<std::string, std::string> > ParamMap;
   ParamMap params_;
 };
 
 TEST_F(DeviceManagementBackendImplTest, RegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   em::DeviceRegisterResponse expected_response;
   expected_response.set_device_management_token("mtoken");
   EXPECT_CALL(mock, HandleRegisterResponse(MessageEquals(expected_response)));
   em::DeviceRegisterRequest request;
-  service_.ProcessRegisterRequest("token", "device id", request, &mock);
+  service_->ProcessRegisterRequest("token", "device id", request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // Check the data the fetcher received.
   const GURL& request_url(fetcher->original_url());
   const GURL service_url(kServiceURL);
   EXPECT_EQ(service_url.scheme(), request_url.scheme());
   EXPECT_EQ(service_url.host(), request_url.host());
   EXPECT_EQ(service_url.port(), request_url.port());
   EXPECT_EQ(service_url.path(), request_url.path());
@@ skipping 21 matching lines @@
                                           200,
                                           ResponseCookies(),
                                           response_data);
 }
 
 TEST_F(DeviceManagementBackendImplTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   em::DeviceUnregisterResponse expected_response;
   EXPECT_CALL(mock, HandleUnregisterResponse(MessageEquals(expected_response)));
   em::DeviceUnregisterRequest request;
-  service_.ProcessUnregisterRequest("dmtokenvalue", request, &mock);
+  service_->ProcessUnregisterRequest("dmtokenvalue", request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // Check the data the fetcher received.
   const GURL& request_url(fetcher->original_url());
   const GURL service_url(kServiceURL);
   EXPECT_EQ(service_url.scheme(), request_url.scheme());
   EXPECT_EQ(service_url.host(), request_url.host());
   EXPECT_EQ(service_url.port(), request_url.port());
   EXPECT_EQ(service_url.path(), request_url.path());
@@ skipping 41 matching lines @@
       em::GenericValue::VALUE_TYPE_BOOL);
   named_value->mutable_value()->set_bool_value(false);
   EXPECT_CALL(mock, HandlePolicyResponse(MessageEquals(expected_response)));
 
   em::DevicePolicyRequest request;
   request.set_policy_scope("chromium");
   em::DevicePolicySettingRequest* setting_request =
       request.add_setting_request();
   setting_request->set_key("policy");
   setting_request->set_watermark("stale");
-  service_.ProcessPolicyRequest("dmtokenvalue", request, &mock);
+  service_->ProcessPolicyRequest("dmtokenvalue", request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // Check the data the fetcher received.
   const GURL& request_url(fetcher->original_url());
   const GURL service_url(kServiceURL);
   EXPECT_EQ(service_url.scheme(), request_url.scheme());
   EXPECT_EQ(service_url.host(), request_url.host());
   EXPECT_EQ(service_url.port(), request_url.port());
   EXPECT_EQ(service_url.path(), request_url.path());
@@ skipping 15 matching lines @@
   response_wrapper.mutable_policy_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
   URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceURL),
                                           status,
                                           200,
                                           ResponseCookies(),
                                           response_data);
 }
 

[markusheintz_, 2010/11/18 12:40:36]

Sorry if this is a dumb question but what exactly is tested by these two tests?
Does resetting the Service cancel the job?

[Mattias Nissler (ping if slow), 2010/11/19 17:21:53]

Yes, that's a reset of a scoped_ptr, so the backend goes out of scope, hence the
callback shouldn't happen (which is what we state in the EXPECT_CALL).

+TEST_F(DeviceManagementBackendImplTest, CancelRegisterRequest) {
+  DeviceRegisterResponseDelegateMock mock;
+  EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
+  em::DeviceRegisterRequest request;
+  service_->ProcessRegisterRequest("token", "device id", request, &mock);
+  TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+
+  // There shouldn't be any callbacks.
+  service_.reset();
+}
+
+TEST_F(DeviceManagementBackendImplTest, CancelUnregisterRequest) {
+  DeviceUnregisterResponseDelegateMock mock;
+  EXPECT_CALL(mock, HandleUnregisterResponse(_)).Times(0);
+  em::DeviceUnregisterRequest request;
+  service_->ProcessUnregisterRequest("dmtokenvalue", request, &mock);
+  TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+
+  // There shouldn't be any callbacks.
+  service_.reset();
+}
+
+TEST_F(DeviceManagementBackendImplTest, CancelPolicyRequest) {
+  DevicePolicyResponseDelegateMock mock;
+  EXPECT_CALL(mock, HandlePolicyResponse(_)).Times(0);
+  em::DevicePolicyRequest request;
+  request.set_policy_scope("chromium");

[markusheintz_, 2010/11/18 12:40:36]

Not sure if this is important for you test, but the value for the policy scope
is "chromeos/device" according to your doc. 

[Mattias Nissler (ping if slow), 2010/11/19 17:21:53]

Done.

+  em::DevicePolicySettingRequest* setting_request =
+      request.add_setting_request();
+  setting_request->set_key("policy");
+  setting_request->set_watermark("stale");
+  service_->ProcessPolicyRequest("dmtokenvalue", request, &mock);
+  TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+
+  // There shouldn't be any callbacks.
+  service_.reset();
+}
+
+TEST_F(DeviceManagementBackendImplTest, BackendSwapping) {
+  // Start with a non-existing backend.
+  backend_.reset();
+
+  // Make a request. We should not see any fetchers being created.
+  DeviceRegisterResponseDelegateMock mock;
+  em::DeviceRegisterResponse expected_response;
+  expected_response.set_device_management_token("mtoken");
+  EXPECT_CALL(mock, HandleRegisterResponse(MessageEquals(expected_response)));
+  em::DeviceRegisterRequest request;
+  service_->ProcessRegisterRequest("token", "device id", request, &mock);
+  TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_FALSE(fetcher);
+
+  // Now create a backend. That should start the job.
+  ResetBackend();
+  fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  factory_.RemoveFetcherFromMap(0);
+
+  // Killing the backend should stop the job.
+  backend_.reset();
+  fetcher = factory_.GetFetcherByID(0);
+  ASSERT_FALSE(fetcher);
+
+  // Recreate the backend and process the job, which should trigger the
+  // callback.
+  ResetBackend();
+  fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+
+  std::string response_data;
+  em::DeviceManagementResponse response_wrapper;
+  response_wrapper.set_error(em::DeviceManagementResponse::SUCCESS);
+  response_wrapper.mutable_register_response()->CopyFrom(expected_response);
+  ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
+  URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
+  fetcher->delegate()->OnURLFetchComplete(fetcher,
+                                          GURL(kServiceURL),
+                                          status,
+                                          200,
+                                          ResponseCookies(),
+                                          response_data);
+}
+
 }  // namespace policy