Always send the device ID when making device management requests.

chrome/browser/policy/device_management_service_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 "base/message_loop.h"
 #include "base/string_split.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/policy/device_management_backend_impl.h"
 #include "chrome/browser/policy/device_management_backend_mock.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/common/net/test_url_fetcher_factory.h"
 #include "chrome/test/test_url_request_context_getter.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 
 namespace policy {
 
 const char kServiceUrl[] = "https://example.com/management_service";
 
 // Encoded error response messages for testing the error code paths.
 const char kResponseEmpty[] = "\x08\x00";
 const char kResponseErrorManagementNotSupported[] = "\x08\x01";
 const char kResponseErrorDeviceNotFound[] = "\x08\x02";
 const char kResponseErrorManagementTokenInvalid[] = "\x08\x03";
 const char kResponseErrorActivationPending[] = "\x08\x04";
 
 #define PROTO_STRING(name) (std::string(name, arraysize(name) - 1))
 
+// Some helper constants.
+const char kAuthToken[] = "auth-token";
+const char kDMToken[] = "device-management-token";
+const char kDeviceId[] = "device-id";
+
 // Unit tests for the device management policy service. The tests are run
 // against a TestURLFetcherFactory that is used to short-circuit the request
 // without calling into the actual network stack.
 template<typename TESTBASE>
 class DeviceManagementServiceTestBase : public TESTBASE {
  protected:
   DeviceManagementServiceTestBase()
       : request_context_(new TestURLRequestContextGetter()),
         io_thread_(BrowserThread::IO, &loop_) {
     ResetService();
@@ skipping 48 matching lines @@
 // the same for all kinds of requests.
 class DeviceManagementServiceFailedRequestTest
     : public DeviceManagementServiceTestBase<
           testing::TestWithParam<FailedRequestParams> > {
 };
 
 TEST_P(DeviceManagementServiceFailedRequestTest, RegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest("token", "device id", request, &mock);
+  backend_->ProcessRegisterRequest(kAuthToken, kDeviceId, 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(DeviceManagementServiceFailedRequestTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DeviceUnregisterRequest request;
-  backend_->ProcessUnregisterRequest("token", request, &mock);
+  backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, 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(DeviceManagementServiceFailedRequestTest, 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");
-  backend_->ProcessPolicyRequest("token", request, &mock);
+  backend_->ProcessPolicyRequest(kDMToken, kDeviceId, 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 31 matching lines @@
             DeviceManagementBackend::kErrorServiceManagementTokenInvalid,
             URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING(kResponseErrorManagementTokenInvalid)),
         FailedRequestParams(
             DeviceManagementBackend::kErrorServiceActivationPending,
             URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING(kResponseErrorActivationPending))));
 
-class DeviceManagementServiceTest
-    : public DeviceManagementServiceTestBase<testing::Test> {
-};
-
-MATCHER_P(MessageEquals, reference, "") {
-  std::string reference_data;
-  std::string arg_data;
-  return arg.SerializeToString(&arg_data) &&
-         reference.SerializeToString(&reference_data) &&
-         arg_data == reference_data;
-}
-
 // Simple query parameter parser for testing.
 class QueryParams {
  public:
   explicit QueryParams(const std::string& query) {
     base::SplitStringIntoKeyValuePairs(query, '=', '&', &params_);
   }
 
   bool Check(const std::string& name, const std::string& expected_value) {
     bool found = false;
     for (ParamMap::const_iterator i(params_.begin()); i != params_.end(); ++i) {
@@ skipping 20 matching lines @@
       }
     }
     return found;
   }
 
  private:
   typedef std::vector<std::pair<std::string, std::string> > ParamMap;
   ParamMap params_;
 };
 
+class DeviceManagementServiceTest
+    : public DeviceManagementServiceTestBase<testing::Test> {
+ protected:
+  void CheckURLAndQueryParams(const GURL& request_url,
+                              const std::string& request_type,
+                              const std::string& device_id) {
+    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());
+
+    QueryParams query_params(request_url.query());
+    EXPECT_TRUE(query_params.Check(
+        DeviceManagementBackendImpl::kParamRequest, request_type));
+    EXPECT_TRUE(query_params.Check(
+        DeviceManagementBackendImpl::kParamDeviceID, device_id));
+    EXPECT_TRUE(query_params.Check(
+        DeviceManagementBackendImpl::kParamDeviceType,
+        DeviceManagementBackendImpl::kValueDeviceType));
+    EXPECT_TRUE(query_params.Check(
+        DeviceManagementBackendImpl::kParamAppType,
+        DeviceManagementBackendImpl::kValueAppType));
+    EXPECT_TRUE(query_params.Check(
+        DeviceManagementBackendImpl::kParamAgent,
+        DeviceManagementBackendImpl::GetAgentString()));
+  }
+};
+
+MATCHER_P(MessageEquals, reference, "") {
+  std::string reference_data;
+  std::string arg_data;
+  return arg.SerializeToString(&arg_data) &&
+         reference.SerializeToString(&reference_data) &&
+         arg_data == reference_data;
+}
+
 TEST_F(DeviceManagementServiceTest, RegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   em::DeviceRegisterResponse expected_response;
-  expected_response.set_device_management_token("mtoken");
+  expected_response.set_device_management_token(kDMToken);
   EXPECT_CALL(mock, HandleRegisterResponse(MessageEquals(expected_response)));
   em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest("token", "device id", request, &mock);
+  backend_->ProcessRegisterRequest(kDMToken, kDeviceId, 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());
-
-  QueryParams query_params(request_url.query());
-  EXPECT_TRUE(query_params.Check("request", "register"));
+  CheckURLAndQueryParams(fetcher->original_url(),
+                         DeviceManagementBackendImpl::kValueRequestRegister,
+                         kDeviceId);
 
   em::DeviceManagementRequest expected_request_wrapper;
   expected_request_wrapper.mutable_register_request()->CopyFrom(request);
   std::string expected_request_data;
   ASSERT_TRUE(expected_request_wrapper.SerializeToString(
       &expected_request_data));
   EXPECT_EQ(expected_request_data, fetcher->upload_data());
 
   // Generate the response.
   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);
 }
 
 TEST_F(DeviceManagementServiceTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   em::DeviceUnregisterResponse expected_response;
   EXPECT_CALL(mock, HandleUnregisterResponse(MessageEquals(expected_response)));
   em::DeviceUnregisterRequest request;
-  backend_->ProcessUnregisterRequest("dmtokenvalue", request, &mock);
+  backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, 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());
 
-  QueryParams query_params(request_url.query());
-  EXPECT_TRUE(query_params.Check("request", "unregister"));
+  CheckURLAndQueryParams(fetcher->original_url(),
+                         DeviceManagementBackendImpl::kValueRequestUnregister,
+                         kDeviceId);
 
   em::DeviceManagementRequest expected_request_wrapper;
   expected_request_wrapper.mutable_unregister_request()->CopyFrom(request);
   std::string expected_request_data;
   ASSERT_TRUE(expected_request_wrapper.SerializeToString(
       &expected_request_data));
   EXPECT_EQ(expected_request_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
@@ skipping 28 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("chromeos/device");
   em::DevicePolicySettingRequest* setting_request =
       request.add_setting_request();
   setting_request->set_key("policy");
   setting_request->set_watermark("stale");
-  backend_->ProcessPolicyRequest("dmtokenvalue", request, &mock);
+  backend_->ProcessPolicyRequest(kDMToken, kDeviceId, 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());
-
-  QueryParams query_params(request_url.query());
-  EXPECT_TRUE(query_params.Check("request", "policy"));
+  CheckURLAndQueryParams(fetcher->original_url(),
+                         DeviceManagementBackendImpl::kValueRequestPolicy,
+                         kDeviceId);
 
   em::DeviceManagementRequest expected_request_wrapper;
   expected_request_wrapper.mutable_policy_request()->CopyFrom(request);
   std::string expected_request_data;
   ASSERT_TRUE(expected_request_wrapper.SerializeToString(
       &expected_request_data));
   EXPECT_EQ(expected_request_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
   em::DeviceManagementResponse response_wrapper;
   response_wrapper.set_error(em::DeviceManagementResponse::SUCCESS);
   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);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
   em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest("token", "device id", request, &mock);
+  backend_->ProcessRegisterRequest(kAuthToken, kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
   backend_.reset();
 }
 
 TEST_F(DeviceManagementServiceTest, CancelUnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   EXPECT_CALL(mock, HandleUnregisterResponse(_)).Times(0);
   em::DeviceUnregisterRequest request;
-  backend_->ProcessUnregisterRequest("dmtokenvalue", request, &mock);
+  backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
   backend_.reset();
 }
 
 TEST_F(DeviceManagementServiceTest, CancelPolicyRequest) {
   DevicePolicyResponseDelegateMock mock;
   EXPECT_CALL(mock, HandlePolicyResponse(_)).Times(0);
   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");
-  backend_->ProcessPolicyRequest("dmtokenvalue", request, &mock);
+  backend_->ProcessPolicyRequest(kDMToken, kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
   backend_.reset();
 }
 
 TEST_F(DeviceManagementServiceTest, JobQueueing) {
   // Start with a non-initialized service.
   ResetService();
 
   // Make a request. We should not see any fetchers being created.
   DeviceRegisterResponseDelegateMock mock;
   em::DeviceRegisterResponse expected_response;
-  expected_response.set_device_management_token("mtoken");
+  expected_response.set_device_management_token(kDMToken);
   EXPECT_CALL(mock, HandleRegisterResponse(MessageEquals(expected_response)));
   em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest("token", "device id", request, &mock);
+  backend_->ProcessRegisterRequest(kAuthToken, kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_FALSE(fetcher);
 
   // Now initialize the service. That should start the job.
   service_->Initialize(request_context_.get());
   fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   factory_.RemoveFetcherFromMap(0);
 
   // Check that the request is processed as expected.
   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