request_handler_for_register_device_and_user_unittest.cc 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/strings/strcat.h"
  5. #include "components/policy/test_support/request_handler_for_register_browser.h"
  6. #include "components/policy/core/common/cloud/cloud_policy_constants.h"
  7. #include "components/policy/test_support/client_storage.h"
  8. #include "components/policy/test_support/embedded_policy_test_server_test_base.h"
  9. #include "components/policy/test_support/policy_storage.h"
  10. #include "device_management_backend.pb.h"
  11. #include "net/http/http_status_code.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace em = enterprise_management;
  14. namespace policy {
  15. namespace {
  16. constexpr char kDeviceId[] = "fake_device_id";
  17. constexpr char kAllowedUserEmail[] = "user@example.com";
  18. constexpr char kDisallowedUserEmail[] = "invalid-user@example.com";
  19. constexpr char kAllowedUserOAuthToken[] = "oauth-token-for-user";
  20. constexpr char kDisallowedUserOAuthToken[] = "oauth-token-for-invalid-user";
  21. constexpr char kMachineModel[] = "iPhone 10";
  22. constexpr char kBrandCode[] = "iPhone";
  23. constexpr char kMachineId[] = "11123";
  24. } // namespace
  25. class RequestHandlerForRegisterDeviceAndUserTest
  26. : public EmbeddedPolicyTestServerTestBase {
  27. protected:
  28. RequestHandlerForRegisterDeviceAndUserTest() = default;
  29. ~RequestHandlerForRegisterDeviceAndUserTest() override = default;
  30. void SetUp() override {
  31. EmbeddedPolicyTestServerTestBase::SetUp();
  32. SetRequestTypeParam(dm_protocol::kValueRequestRegister);
  33. SetAppType(dm_protocol::kValueAppType);
  34. SetDeviceIdParam(kDeviceId);
  35. SetDeviceType(dm_protocol::kValueDeviceType);
  36. }
  37. };
  38. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  39. HandleRequest_NoEnrollmentToken) {
  40. StartRequestAndWait();
  41. EXPECT_EQ(GetResponseCode(), net::HTTP_UNAUTHORIZED);
  42. EXPECT_EQ(client_storage()->GetNumberOfRegisteredClients(), 0u);
  43. }
  44. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  45. HandleRequest_NoManagedUsers) {
  46. SetGoogleLoginTokenHeader(kAllowedUserOAuthToken);
  47. StartRequestAndWait();
  48. EXPECT_EQ(GetResponseCode(), net::HTTP_INTERNAL_SERVER_ERROR);
  49. EXPECT_EQ(client_storage()->GetNumberOfRegisteredClients(), 0u);
  50. }
  51. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  52. HandleRequest_UserNotAllowed) {
  53. policy_storage()->add_managed_user(kAllowedUserEmail);
  54. SetGoogleLoginTokenHeader(kDisallowedUserOAuthToken);
  55. policy_storage()->set_policy_user(kDisallowedUserEmail);
  56. StartRequestAndWait();
  57. EXPECT_EQ(GetResponseCode(), net::HTTP_FORBIDDEN);
  58. EXPECT_EQ(client_storage()->GetNumberOfRegisteredClients(), 0u);
  59. }
  60. TEST_F(RequestHandlerForRegisterDeviceAndUserTest, HandleRequest_Success) {
  61. policy_storage()->add_managed_user(kAllowedUserEmail);
  62. SetGoogleLoginTokenHeader(kAllowedUserOAuthToken);
  63. policy_storage()->set_policy_user(kAllowedUserEmail);
  64. policy_storage()->SetPsmEntry(
  65. base::StrCat({kBrandCode, "_", kMachineId}),
  66. PolicyStorage::PsmEntry{
  67. .psm_execution_result =
  68. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE,
  69. .psm_determination_timestamp = 42});
  70. em::DeviceManagementRequest device_management_request;
  71. em::DeviceRegisterRequest* register_request =
  72. device_management_request.mutable_register_request();
  73. register_request->set_machine_model(kMachineModel);
  74. register_request->set_type(em::DeviceRegisterRequest::USER);
  75. register_request->set_brand_code(kBrandCode);
  76. register_request->set_machine_id(kMachineId);
  77. register_request->set_psm_execution_result(
  78. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE);
  79. register_request->set_psm_determination_timestamp_ms(42);
  80. SetPayload(device_management_request);
  81. StartRequestAndWait();
  82. EXPECT_EQ(GetResponseCode(), net::HTTP_OK);
  83. ASSERT_TRUE(HasResponseBody());
  84. em::DeviceManagementResponse device_management_response =
  85. GetDeviceManagementResponse();
  86. const em::DeviceRegisterResponse& register_response =
  87. device_management_response.register_response();
  88. EXPECT_FALSE(register_response.device_management_token().empty());
  89. EXPECT_FALSE(register_response.machine_name().empty());
  90. EXPECT_EQ(register_response.enrollment_type(),
  91. em::DeviceRegisterResponse::ENTERPRISE);
  92. ASSERT_EQ(client_storage()->GetNumberOfRegisteredClients(), 1u);
  93. const ClientStorage::ClientInfo* client_info =
  94. client_storage()->GetClientOrNull(kDeviceId);
  95. ASSERT_NE(client_info, nullptr);
  96. EXPECT_EQ(client_info->device_id, kDeviceId);
  97. EXPECT_EQ(client_info->device_token,
  98. register_response.device_management_token());
  99. EXPECT_EQ(client_info->machine_name, register_response.machine_name());
  100. EXPECT_EQ(client_info->username, kAllowedUserEmail);
  101. EXPECT_FALSE(client_info->allowed_policy_types.empty());
  102. }
  103. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  104. HandleRequest_NoPsmExecutionResult) {
  105. policy_storage()->add_managed_user(kAllowedUserEmail);
  106. SetGoogleLoginTokenHeader(kAllowedUserOAuthToken);
  107. policy_storage()->set_policy_user(kAllowedUserEmail);
  108. policy_storage()->SetPsmEntry(
  109. base::StrCat({kBrandCode, "_", kMachineId}),
  110. PolicyStorage::PsmEntry{
  111. .psm_execution_result =
  112. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE,
  113. .psm_determination_timestamp = 42});
  114. em::DeviceManagementRequest device_management_request;
  115. em::DeviceRegisterRequest* register_request =
  116. device_management_request.mutable_register_request();
  117. register_request->set_machine_model(kMachineModel);
  118. register_request->set_type(em::DeviceRegisterRequest::USER);
  119. register_request->set_brand_code(kBrandCode);
  120. register_request->set_machine_id(kMachineId);
  121. register_request->set_psm_determination_timestamp_ms(42);
  122. SetPayload(device_management_request);
  123. StartRequestAndWait();
  124. EXPECT_EQ(GetResponseCode(), net::HTTP_BAD_REQUEST);
  125. }
  126. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  127. HandleRequest_NoPsmDeterminationTimestamp) {
  128. policy_storage()->add_managed_user(kAllowedUserEmail);
  129. SetGoogleLoginTokenHeader(kAllowedUserOAuthToken);
  130. policy_storage()->set_policy_user(kAllowedUserEmail);
  131. policy_storage()->SetPsmEntry(
  132. base::StrCat({kBrandCode, "_", kMachineId}),
  133. PolicyStorage::PsmEntry{
  134. .psm_execution_result =
  135. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE,
  136. .psm_determination_timestamp = 42});
  137. em::DeviceManagementRequest device_management_request;
  138. em::DeviceRegisterRequest* register_request =
  139. device_management_request.mutable_register_request();
  140. register_request->set_machine_model(kMachineModel);
  141. register_request->set_type(em::DeviceRegisterRequest::USER);
  142. register_request->set_brand_code(kBrandCode);
  143. register_request->set_machine_id(kMachineId);
  144. register_request->set_psm_execution_result(
  145. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE);
  146. SetPayload(device_management_request);
  147. StartRequestAndWait();
  148. EXPECT_EQ(GetResponseCode(), net::HTTP_BAD_REQUEST);
  149. }
  150. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  151. HandleRequest_MismatchingPsmExecutionResult) {
  152. policy_storage()->add_managed_user(kAllowedUserEmail);
  153. SetGoogleLoginTokenHeader(kAllowedUserOAuthToken);
  154. policy_storage()->set_policy_user(kAllowedUserEmail);
  155. policy_storage()->SetPsmEntry(
  156. base::StrCat({kBrandCode, "_", kMachineId}),
  157. PolicyStorage::PsmEntry{
  158. .psm_execution_result =
  159. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE,
  160. .psm_determination_timestamp = 42});
  161. em::DeviceManagementRequest device_management_request;
  162. em::DeviceRegisterRequest* register_request =
  163. device_management_request.mutable_register_request();
  164. register_request->set_machine_model(kMachineModel);
  165. register_request->set_type(em::DeviceRegisterRequest::USER);
  166. register_request->set_brand_code(kBrandCode);
  167. register_request->set_machine_id(kMachineId);
  168. register_request->set_psm_execution_result(
  169. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITHOUT_STATE);
  170. register_request->set_psm_determination_timestamp_ms(42);
  171. SetPayload(device_management_request);
  172. StartRequestAndWait();
  173. EXPECT_EQ(GetResponseCode(), net::HTTP_BAD_REQUEST);
  174. }
  175. TEST_F(RequestHandlerForRegisterDeviceAndUserTest,
  176. HandleRequest_MismatchingPsmDeterminationTimestamp) {
  177. policy_storage()->add_managed_user(kAllowedUserEmail);
  178. SetGoogleLoginTokenHeader(kAllowedUserOAuthToken);
  179. policy_storage()->set_policy_user(kAllowedUserEmail);
  180. policy_storage()->SetPsmEntry(
  181. base::StrCat({kBrandCode, "_", kMachineId}),
  182. PolicyStorage::PsmEntry{
  183. .psm_execution_result =
  184. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITH_STATE,
  185. .psm_determination_timestamp = 42});
  186. em::DeviceManagementRequest device_management_request;
  187. em::DeviceRegisterRequest* register_request =
  188. device_management_request.mutable_register_request();
  189. register_request->set_machine_model(kMachineModel);
  190. register_request->set_type(em::DeviceRegisterRequest::USER);
  191. register_request->set_brand_code(kBrandCode);
  192. register_request->set_machine_id(kMachineId);
  193. register_request->set_psm_execution_result(
  194. em::DeviceRegisterRequest::PSM_RESULT_SUCCESSFUL_WITHOUT_STATE);
  195. register_request->set_psm_determination_timestamp_ms(24);
  196. SetPayload(device_management_request);
  197. StartRequestAndWait();
  198. EXPECT_EQ(GetResponseCode(), net::HTTP_BAD_REQUEST);
  199. }
  200. } // namespace policy