pairing_registry_delegate_win_unittest.cc 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133
  1. // Copyright 2013 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 <memory>
  5. #include <utility>
  6. #include "remoting/host/pairing_registry_delegate_win.h"
  7. #include "base/guid.h"
  8. #include "base/strings/utf_string_conversions.h"
  9. #include "base/values.h"
  10. #include "base/win/registry.h"
  11. #include "base/win/shlwapi.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace remoting {
  14. using protocol::PairingRegistry;
  15. class PairingRegistryDelegateWinTest : public testing::Test {
  16. public:
  17. void SetUp() override {
  18. key_name_ = base::GenerateGUID();
  19. base::win::RegKey root;
  20. EXPECT_TRUE(root.Create(HKEY_CURRENT_USER,
  21. base::UTF8ToWide(key_name_).c_str(),
  22. KEY_READ | KEY_WRITE) == ERROR_SUCCESS);
  23. EXPECT_TRUE(privileged_.Create(root.Handle(), L"privileged",
  24. KEY_READ | KEY_WRITE) == ERROR_SUCCESS);
  25. EXPECT_TRUE(unprivileged_.Create(root.Handle(), L"unprivileged",
  26. KEY_READ | KEY_WRITE) == ERROR_SUCCESS);
  27. }
  28. void TearDown() override {
  29. privileged_.Close();
  30. unprivileged_.Close();
  31. EXPECT_TRUE(
  32. SHDeleteKey(HKEY_CURRENT_USER,
  33. base::UTF8ToWide(key_name_).c_str()) == ERROR_SUCCESS);
  34. }
  35. protected:
  36. std::string key_name_;
  37. base::win::RegKey privileged_;
  38. base::win::RegKey unprivileged_;
  39. };
  40. TEST_F(PairingRegistryDelegateWinTest, SaveAndLoad) {
  41. std::unique_ptr<PairingRegistryDelegateWin> delegate(
  42. new PairingRegistryDelegateWin());
  43. delegate->SetRootKeys(privileged_.Handle(), unprivileged_.Handle());
  44. // Check that registry is initially empty.
  45. EXPECT_TRUE(delegate->LoadAll().empty());
  46. // Add a couple of pairings.
  47. PairingRegistry::Pairing pairing1(base::Time::Now(), "xxx", "xxx", "xxx");
  48. PairingRegistry::Pairing pairing2(base::Time::Now(), "yyy", "yyy", "yyy");
  49. EXPECT_TRUE(delegate->Save(pairing1));
  50. EXPECT_TRUE(delegate->Save(pairing2));
  51. // Verify that there are two pairings in the store now.
  52. EXPECT_EQ(delegate->LoadAll().size(), 2u);
  53. // Verify that they can be retrieved.
  54. EXPECT_EQ(delegate->Load(pairing1.client_id()), pairing1);
  55. EXPECT_EQ(delegate->Load(pairing2.client_id()), pairing2);
  56. // Delete the first pairing.
  57. EXPECT_TRUE(delegate->Delete(pairing1.client_id()));
  58. // Verify that there is only one pairing left.
  59. EXPECT_EQ(delegate->Load(pairing1.client_id()), PairingRegistry::Pairing());
  60. EXPECT_EQ(delegate->Load(pairing2.client_id()), pairing2);
  61. // Verify that the only remaining value is |pairing2|.
  62. EXPECT_EQ(delegate->LoadAll().size(), 1u);
  63. base::Value::List pairings = delegate->LoadAll();
  64. ASSERT_TRUE(pairings[0].is_dict());
  65. EXPECT_EQ(PairingRegistry::Pairing::CreateFromValue(
  66. std::move(pairings[0].GetDict())),
  67. pairing2);
  68. // Delete the rest and verify.
  69. EXPECT_TRUE(delegate->DeleteAll());
  70. EXPECT_TRUE(delegate->LoadAll().empty());
  71. }
  72. // Verifies that the delegate is stateless by using two different instances.
  73. TEST_F(PairingRegistryDelegateWinTest, Stateless) {
  74. std::unique_ptr<PairingRegistryDelegateWin> load_delegate(
  75. new PairingRegistryDelegateWin());
  76. load_delegate->SetRootKeys(privileged_.Handle(), unprivileged_.Handle());
  77. std::unique_ptr<PairingRegistryDelegateWin> save_delegate(
  78. new PairingRegistryDelegateWin());
  79. save_delegate->SetRootKeys(privileged_.Handle(), unprivileged_.Handle());
  80. PairingRegistry::Pairing pairing(base::Time::Now(), "xxx", "xxx", "xxx");
  81. EXPECT_TRUE(save_delegate->Save(pairing));
  82. EXPECT_EQ(load_delegate->Load(pairing.client_id()), pairing);
  83. }
  84. TEST_F(PairingRegistryDelegateWinTest, Unprivileged) {
  85. std::unique_ptr<PairingRegistryDelegateWin> delegate(
  86. new PairingRegistryDelegateWin());
  87. delegate->SetRootKeys(privileged_.Handle(), unprivileged_.Handle());
  88. PairingRegistry::Pairing pairing(base::Time::Now(), "xxx", "xxx", "xxx");
  89. EXPECT_TRUE(delegate->Save(pairing));
  90. EXPECT_EQ(delegate->Load(pairing.client_id()), pairing);
  91. // Strip the delegate from write access and validate that it still can be used
  92. // to read the pairings.
  93. delegate = std::make_unique<PairingRegistryDelegateWin>();
  94. delegate->SetRootKeys(nullptr, unprivileged_.Handle());
  95. PairingRegistry::Pairing unprivileged_pairing =
  96. delegate->Load(pairing.client_id());
  97. EXPECT_EQ(pairing.client_id(), unprivileged_pairing.client_id());
  98. EXPECT_EQ(pairing.client_name(), unprivileged_pairing.client_name());
  99. EXPECT_EQ(pairing.created_time(), unprivileged_pairing.created_time());
  100. // Verify that the shared secret if not available.
  101. EXPECT_TRUE(unprivileged_pairing.shared_secret().empty());
  102. // Verify that a pairing cannot be saved.
  103. EXPECT_FALSE(delegate->Save(pairing));
  104. }
  105. } // namespace remoting