remoting/host/pairing_registry_delegate_win_unittest.cc

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