remote_device_test_util.cc 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  1. // Copyright 2016 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 <map>
  5. #include <string>
  6. #include "ash/components/multidevice/remote_device_test_util.h"
  7. #include "base/base64.h"
  8. #include "base/base64url.h"
  9. #include "base/strings/string_number_conversions.h"
  10. namespace ash::multidevice {
  11. namespace {
  12. // Attributes of the default test remote device.
  13. const char kTestRemoteDeviceUserId[] = "example@gmail.com";
  14. const int64_t kTestRemoteDeviceInstanceId = 0L;
  15. const char kTestRemoteDevicePiiFreeName[] = "no-pii device";
  16. const char kTestRemoteDevicePSK[] = "remote device psk";
  17. const int64_t kTestRemoteDeviceLastUpdateTimeMillis = 0L;
  18. const char kBeaconSeedData[] = "beacon seed data";
  19. const int64_t kBeaconSeedStartTimeMillis = 100L;
  20. const int64_t kBeaconSeedEndTimeMillis = 200L;
  21. // Create an Instance ID, which is a base64 URL-safe encoding of an 8-byte
  22. // integer. This seems like overkill for tests, but some places in code might
  23. // require the specific Instance ID formatting.
  24. std::string InstanceIdFromInt64(int64_t number) {
  25. // Big-endian representation of |number|.
  26. uint8_t bytes[sizeof(int64_t)];
  27. bytes[0] = static_cast<uint8_t>((number >> 56) & 0xff);
  28. bytes[1] = static_cast<uint8_t>((number >> 48) & 0xff);
  29. bytes[2] = static_cast<uint8_t>((number >> 40) & 0xff);
  30. bytes[3] = static_cast<uint8_t>((number >> 32) & 0xff);
  31. bytes[4] = static_cast<uint8_t>((number >> 24) & 0xff);
  32. bytes[5] = static_cast<uint8_t>((number >> 16) & 0xff);
  33. bytes[6] = static_cast<uint8_t>((number >> 8) & 0xff);
  34. bytes[7] = static_cast<uint8_t>(number & 0xff);
  35. // Transforms the first 4 bits to 0x7 which is required for Instance IDs.
  36. bytes[0] &= 0x0f;
  37. bytes[0] |= 0x70;
  38. std::string iid;
  39. base::Base64UrlEncode(
  40. base::StringPiece(reinterpret_cast<const char*>(bytes), sizeof(bytes)),
  41. base::Base64UrlEncodePolicy::OMIT_PADDING, &iid);
  42. return iid;
  43. }
  44. } // namespace
  45. // Attributes of the default test remote device.
  46. const char kTestRemoteDeviceName[] = "remote device";
  47. const char kTestRemoteDevicePublicKey[] = "public key";
  48. const char kTestRemoteDeviceBluetoothPublicAddress[] = "01:23:45:67:89:AB";
  49. RemoteDeviceRefBuilder::RemoteDeviceRefBuilder() {
  50. remote_device_ = std::make_shared<RemoteDevice>(CreateRemoteDeviceForTest());
  51. }
  52. RemoteDeviceRefBuilder::~RemoteDeviceRefBuilder() = default;
  53. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetUserEmail(
  54. const std::string& user_email) {
  55. remote_device_->user_email = user_email;
  56. return *this;
  57. }
  58. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetInstanceId(
  59. const std::string& instance_id) {
  60. remote_device_->instance_id = instance_id;
  61. return *this;
  62. }
  63. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetName(
  64. const std::string& name) {
  65. remote_device_->name = name;
  66. return *this;
  67. }
  68. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetPiiFreeName(
  69. const std::string& pii_free_name) {
  70. remote_device_->pii_free_name = pii_free_name;
  71. return *this;
  72. }
  73. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetPublicKey(
  74. const std::string& public_key) {
  75. remote_device_->public_key = public_key;
  76. return *this;
  77. }
  78. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetSupportsMobileHotspot(
  79. bool supports_mobile_hotspot) {
  80. remote_device_->software_features[SoftwareFeature::kInstantTetheringHost] =
  81. supports_mobile_hotspot ? SoftwareFeatureState::kSupported
  82. : SoftwareFeatureState::kNotSupported;
  83. return *this;
  84. }
  85. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetSoftwareFeatureState(
  86. const SoftwareFeature feature,
  87. const SoftwareFeatureState new_state) {
  88. remote_device_->software_features[feature] = new_state;
  89. return *this;
  90. }
  91. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetLastUpdateTimeMillis(
  92. int64_t last_update_time_millis) {
  93. remote_device_->last_update_time_millis = last_update_time_millis;
  94. return *this;
  95. }
  96. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetBeaconSeeds(
  97. const std::vector<BeaconSeed>& beacon_seeds) {
  98. remote_device_->beacon_seeds = beacon_seeds;
  99. return *this;
  100. }
  101. RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetBluetoothPublicAddress(
  102. const std::string& bluetooth_public_address) {
  103. remote_device_->bluetooth_public_address = bluetooth_public_address;
  104. return *this;
  105. }
  106. RemoteDeviceRef RemoteDeviceRefBuilder::Build() {
  107. return RemoteDeviceRef(remote_device_);
  108. }
  109. RemoteDevice CreateRemoteDeviceForTest() {
  110. std::map<SoftwareFeature, SoftwareFeatureState> software_features;
  111. software_features[SoftwareFeature::kSmartLockHost] =
  112. SoftwareFeatureState::kEnabled;
  113. software_features[SoftwareFeature::kInstantTetheringHost] =
  114. SoftwareFeatureState::kSupported;
  115. return RemoteDevice(
  116. kTestRemoteDeviceUserId, InstanceIdFromInt64(kTestRemoteDeviceInstanceId),
  117. kTestRemoteDeviceName, kTestRemoteDevicePiiFreeName,
  118. kTestRemoteDevicePublicKey, kTestRemoteDevicePSK,
  119. kTestRemoteDeviceLastUpdateTimeMillis, software_features,
  120. {multidevice::BeaconSeed(
  121. kBeaconSeedData, base::Time::FromJavaTime(kBeaconSeedStartTimeMillis),
  122. base::Time::FromJavaTime(kBeaconSeedEndTimeMillis))},
  123. kTestRemoteDeviceBluetoothPublicAddress);
  124. }
  125. RemoteDeviceRef CreateRemoteDeviceRefForTest() {
  126. return RemoteDeviceRefBuilder().Build();
  127. }
  128. RemoteDeviceRefList CreateRemoteDeviceRefListForTest(size_t num_to_create) {
  129. RemoteDeviceRefList generated_devices;
  130. for (size_t i = 0; i < num_to_create; i++) {
  131. RemoteDeviceRef remote_device =
  132. RemoteDeviceRefBuilder()
  133. .SetInstanceId(InstanceIdFromInt64(i))
  134. .SetPublicKey("publicKey" + base::NumberToString(i))
  135. .Build();
  136. generated_devices.push_back(remote_device);
  137. }
  138. return generated_devices;
  139. }
  140. RemoteDeviceList CreateRemoteDeviceListForTest(size_t num_to_create) {
  141. RemoteDeviceList generated_devices;
  142. for (size_t i = 0; i < num_to_create; i++) {
  143. RemoteDevice remote_device = CreateRemoteDeviceForTest();
  144. remote_device.instance_id = InstanceIdFromInt64(i);
  145. remote_device.public_key = "publicKey" + base::NumberToString(i);
  146. generated_devices.push_back(remote_device);
  147. }
  148. return generated_devices;
  149. }
  150. RemoteDevice* GetMutableRemoteDevice(const RemoteDeviceRef& remote_device_ref) {
  151. const RemoteDevice* remote_device = remote_device_ref.remote_device_.get();
  152. return const_cast<RemoteDevice*>(remote_device);
  153. }
  154. bool IsSameDevice(const RemoteDevice& remote_device,
  155. RemoteDeviceRef remote_device_ref) {
  156. if (!remote_device_ref.remote_device_)
  157. return false;
  158. return remote_device == *remote_device_ref.remote_device_;
  159. }
  160. } // namespace ash::multidevice