request_handler_for_register_cert_based_unittest.cc 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123
  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/gmock/include/gmock/gmock.h"
  13. #include "testing/gtest/include/gtest/gtest.h"
  14. namespace em = enterprise_management;
  15. namespace policy {
  16. namespace {
  17. using testing::IsEmpty;
  18. constexpr char kDeviceId[] = "fake_device_id";
  19. constexpr char kMachineModel[] = "iPhone 10";
  20. constexpr char kBrandCode[] = "iPhone";
  21. constexpr char kMachineId[] = "11123";
  22. constexpr char kExtraData[] = "fake_extra_data";
  23. } // namespace
  24. class RequestHandlerForRegisterCertBasedTest
  25. : public EmbeddedPolicyTestServerTestBase {
  26. protected:
  27. RequestHandlerForRegisterCertBasedTest() = default;
  28. ~RequestHandlerForRegisterCertBasedTest() override = default;
  29. void SetUp() override {
  30. EmbeddedPolicyTestServerTestBase::SetUp();
  31. SetRequestTypeParam(dm_protocol::kValueRequestCertBasedRegister);
  32. SetAppType(dm_protocol::kValueAppType);
  33. SetDeviceIdParam(kDeviceId);
  34. SetDeviceType(dm_protocol::kValueDeviceType);
  35. }
  36. };
  37. TEST_F(RequestHandlerForRegisterCertBasedTest, HandleRequest_Success) {
  38. em::CertificateBasedDeviceRegistrationData register_data;
  39. register_data.set_certificate_type(
  40. em::CertificateBasedDeviceRegistrationData::
  41. ENTERPRISE_ENROLLMENT_CERTIFICATE);
  42. em::DeviceRegisterRequest* register_request =
  43. register_data.mutable_device_register_request();
  44. register_request->set_machine_model(kMachineModel);
  45. register_request->set_type(em::DeviceRegisterRequest::USER);
  46. register_request->set_brand_code(kBrandCode);
  47. register_request->set_machine_id(kMachineId);
  48. em::DeviceManagementRequest device_management_request;
  49. em::CertificateBasedDeviceRegisterRequest* cert_request =
  50. device_management_request.mutable_certificate_based_register_request();
  51. cert_request->mutable_signed_request()->set_data(
  52. register_data.SerializeAsString() + kExtraData);
  53. cert_request->mutable_signed_request()->set_extra_data_bytes(
  54. std::string(kExtraData).length());
  55. SetPayload(device_management_request);
  56. StartRequestAndWait();
  57. EXPECT_EQ(GetResponseCode(), net::HTTP_OK);
  58. ASSERT_TRUE(HasResponseBody());
  59. auto response = GetDeviceManagementResponse();
  60. EXPECT_FALSE(response.register_response().device_management_token().empty());
  61. EXPECT_FALSE(response.register_response().machine_name().empty());
  62. EXPECT_EQ(response.register_response().enrollment_type(),
  63. em::DeviceRegisterResponse::ENTERPRISE);
  64. ASSERT_EQ(client_storage()->GetNumberOfRegisteredClients(), 1u);
  65. const ClientStorage::ClientInfo* client_info =
  66. client_storage()->GetClientOrNull(kDeviceId);
  67. ASSERT_NE(client_info, nullptr);
  68. EXPECT_EQ(client_info->device_id, kDeviceId);
  69. EXPECT_EQ(client_info->device_token,
  70. response.register_response().device_management_token());
  71. EXPECT_EQ(client_info->machine_name,
  72. response.register_response().machine_name());
  73. EXPECT_FALSE(client_info->username.has_value());
  74. EXPECT_FALSE(client_info->allowed_policy_types.empty());
  75. }
  76. TEST_F(RequestHandlerForRegisterCertBasedTest, HandleRequest_InvalidData) {
  77. em::DeviceManagementRequest device_management_request;
  78. em::CertificateBasedDeviceRegisterRequest* cert_request =
  79. device_management_request.mutable_certificate_based_register_request();
  80. cert_request->mutable_signed_request()->set_data(kExtraData);
  81. cert_request->mutable_signed_request()->set_extra_data_bytes(0);
  82. SetPayload(device_management_request);
  83. StartRequestAndWait();
  84. EXPECT_EQ(GetResponseCode(), net::HTTP_BAD_REQUEST);
  85. }
  86. TEST_F(RequestHandlerForRegisterCertBasedTest,
  87. HandleRequest_MissingCertificateType) {
  88. em::CertificateBasedDeviceRegistrationData register_data;
  89. em::DeviceManagementRequest device_management_request;
  90. em::CertificateBasedDeviceRegisterRequest* cert_request =
  91. device_management_request.mutable_certificate_based_register_request();
  92. cert_request->mutable_signed_request()->set_data(
  93. register_data.SerializeAsString());
  94. cert_request->mutable_signed_request()->set_extra_data_bytes(0);
  95. SetPayload(device_management_request);
  96. StartRequestAndWait();
  97. EXPECT_EQ(GetResponseCode(), net::HTTP_FORBIDDEN);
  98. }
  99. } // namespace policy