src/remoting/host/policy_hack/policy_watcher_unittest.cc

   1 // Copyright (c) 2012 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 "base/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/synchronization/waitable_event.h"
   9 #include "remoting/host/dns_blackhole_checker.h"
  10 #include "remoting/host/policy_hack/fake_policy_watcher.h"
  11 #include "remoting/host/policy_hack/mock_policy_callback.h"
  12 #include "remoting/host/policy_hack/policy_watcher.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace remoting {
  17 namespace policy_hack {
  18
  19 class PolicyWatcherTest : public testing::Test {
  20  public:
  21   PolicyWatcherTest() {
  22   }
  23
  24   virtual void SetUp() OVERRIDE {
  25     message_loop_proxy_ = base::MessageLoopProxy::current();
  26     policy_callback_ = base::Bind(&MockPolicyCallback::OnPolicyUpdate,
  27                                   base::Unretained(&mock_policy_callback_));
  28     policy_watcher_.reset(new FakePolicyWatcher(message_loop_proxy_));
  29     nat_true_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
  30     nat_false_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
  31     nat_one_.SetInteger(PolicyWatcher::kNatPolicyName, 1);
  32     domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName,
  33                             std::string());
  34     domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName, kHostDomain);
  35     SetDefaults(nat_true_others_default_);
  36     nat_true_others_default_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
  37     SetDefaults(nat_false_others_default_);
  38     nat_false_others_default_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
  39     SetDefaults(domain_empty_others_default_);
  40     domain_empty_others_default_.SetString(PolicyWatcher::kHostDomainPolicyName,
  41                                            std::string());
  42     SetDefaults(domain_full_others_default_);
  43     domain_full_others_default_.SetString(PolicyWatcher::kHostDomainPolicyName,
  44                                           kHostDomain);
  45     nat_true_domain_empty_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
  46     nat_true_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName,
  47                                      std::string());
  48     nat_true_domain_full_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
  49     nat_true_domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName,
  50                                    kHostDomain);
  51     nat_false_domain_empty_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
  52     nat_false_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName,
  53                                       std::string());
  54     nat_false_domain_full_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
  55     nat_false_domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName,
  56                                     kHostDomain);
  57     SetDefaults(nat_true_domain_empty_others_default_);
  58     nat_true_domain_empty_others_default_.SetBoolean(
  59         PolicyWatcher::kNatPolicyName, true);
  60     nat_true_domain_empty_others_default_.SetString(
  61         PolicyWatcher::kHostDomainPolicyName, std::string());
  62     unknown_policies_.SetString("UnknownPolicyOne", std::string());
  63     unknown_policies_.SetString("UnknownPolicyTwo", std::string());
  64
  65     const char kOverrideNatTraversalToFalse[] =
  66       "{ \"RemoteAccessHostFirewallTraversal\": false }";
  67     nat_true_and_overridden_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
  68     nat_true_and_overridden_.SetString(
  69         PolicyWatcher::kHostDebugOverridePoliciesName,
  70         kOverrideNatTraversalToFalse);
  71     pairing_true_.SetBoolean(PolicyWatcher::kHostAllowClientPairing, true);
  72     pairing_false_.SetBoolean(PolicyWatcher::kHostAllowClientPairing, false);
  73 #if !defined(NDEBUG)
  74     SetDefaults(nat_false_overridden_others_default_);
  75     nat_false_overridden_others_default_.SetBoolean(
  76         PolicyWatcher::kNatPolicyName, false);
  77     nat_false_overridden_others_default_.SetString(
  78         PolicyWatcher::kHostDebugOverridePoliciesName,
  79         kOverrideNatTraversalToFalse);
  80 #endif
  81   }
  82
  83  protected:
  84   void StartWatching() {
  85     policy_watcher_->StartWatching(policy_callback_);
  86     message_loop_.RunUntilIdle();
  87   }
  88
  89   void StopWatching() {
  90     base::WaitableEvent stop_event(false, false);
  91     policy_watcher_->StopWatching(&stop_event);
  92     message_loop_.RunUntilIdle();
  93     EXPECT_EQ(true, stop_event.IsSignaled());
  94   }
  95
  96   static const char* kHostDomain;
  97   base::MessageLoop message_loop_;
  98   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
  99   MockPolicyCallback mock_policy_callback_;
 100   PolicyWatcher::PolicyCallback policy_callback_;
 101   scoped_ptr<FakePolicyWatcher> policy_watcher_;
 102   base::DictionaryValue empty_;
 103   base::DictionaryValue nat_true_;
 104   base::DictionaryValue nat_false_;
 105   base::DictionaryValue nat_one_;
 106   base::DictionaryValue domain_empty_;
 107   base::DictionaryValue domain_full_;
 108   base::DictionaryValue nat_true_others_default_;
 109   base::DictionaryValue nat_false_others_default_;
 110   base::DictionaryValue domain_empty_others_default_;
 111   base::DictionaryValue domain_full_others_default_;
 112   base::DictionaryValue nat_true_domain_empty_;
 113   base::DictionaryValue nat_true_domain_full_;
 114   base::DictionaryValue nat_false_domain_empty_;
 115   base::DictionaryValue nat_false_domain_full_;
 116   base::DictionaryValue nat_true_domain_empty_others_default_;
 117   base::DictionaryValue unknown_policies_;
 118   base::DictionaryValue nat_true_and_overridden_;
 119   base::DictionaryValue nat_false_overridden_others_default_;
 120   base::DictionaryValue pairing_true_;
 121   base::DictionaryValue pairing_false_;
 122
 123  private:
 124   void SetDefaults(base::DictionaryValue& dict) {
 125     dict.SetBoolean(PolicyWatcher::kNatPolicyName, true);
 126     dict.SetBoolean(PolicyWatcher::kHostRequireTwoFactorPolicyName, false);
 127     dict.SetString(PolicyWatcher::kHostDomainPolicyName, std::string());
 128     dict.SetBoolean(PolicyWatcher::kHostMatchUsernamePolicyName, false);
 129     dict.SetString(PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
 130                    kDefaultHostTalkGadgetPrefix);
 131     dict.SetBoolean(PolicyWatcher::kHostRequireCurtainPolicyName, false);
 132     dict.SetString(PolicyWatcher::kHostTokenUrlPolicyName, std::string());
 133     dict.SetString(PolicyWatcher::kHostTokenValidationUrlPolicyName,
 134                    std::string());
 135     dict.SetBoolean(PolicyWatcher::kHostAllowClientPairing, true);
 136 #if !defined(NDEBUG)
 137     dict.SetString(PolicyWatcher::kHostDebugOverridePoliciesName, "");
 138 #endif
 139   }
 140 };
 141
 142 const char* PolicyWatcherTest::kHostDomain = "google.com";
 143
 144 MATCHER_P(IsPolicies, dict, "") {
 145   return arg->Equals(dict);
 146 }
 147
 148 TEST_F(PolicyWatcherTest, None) {
 149   EXPECT_CALL(mock_policy_callback_,
 150               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 151
 152   StartWatching();
 153   policy_watcher_->SetPolicies(&empty_);
 154   StopWatching();
 155 }
 156
 157 TEST_F(PolicyWatcherTest, NatTrue) {
 158   EXPECT_CALL(mock_policy_callback_,
 159               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 160
 161   StartWatching();
 162   policy_watcher_->SetPolicies(&nat_true_);
 163   StopWatching();
 164 }
 165
 166 TEST_F(PolicyWatcherTest, NatFalse) {
 167   EXPECT_CALL(mock_policy_callback_,
 168               OnPolicyUpdatePtr(IsPolicies(&nat_false_others_default_)));
 169
 170   StartWatching();
 171   policy_watcher_->SetPolicies(&nat_false_);
 172   StopWatching();
 173 }
 174
 175 TEST_F(PolicyWatcherTest, NatOne) {
 176   EXPECT_CALL(mock_policy_callback_,
 177               OnPolicyUpdatePtr(IsPolicies(&nat_false_others_default_)));
 178
 179   StartWatching();
 180   policy_watcher_->SetPolicies(&nat_one_);
 181   StopWatching();
 182 }
 183
 184 TEST_F(PolicyWatcherTest, DomainEmpty) {
 185   EXPECT_CALL(mock_policy_callback_,
 186               OnPolicyUpdatePtr(IsPolicies(&domain_empty_others_default_)));
 187
 188   StartWatching();
 189   policy_watcher_->SetPolicies(&domain_empty_);
 190   StopWatching();
 191 }
 192
 193 TEST_F(PolicyWatcherTest, DomainFull) {
 194   EXPECT_CALL(mock_policy_callback_,
 195               OnPolicyUpdatePtr(IsPolicies(&domain_full_others_default_)));
 196
 197   StartWatching();
 198   policy_watcher_->SetPolicies(&domain_full_);
 199   StopWatching();
 200 }
 201
 202 TEST_F(PolicyWatcherTest, NatNoneThenTrue) {
 203   EXPECT_CALL(mock_policy_callback_,
 204               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 205
 206   StartWatching();
 207   policy_watcher_->SetPolicies(&empty_);
 208   policy_watcher_->SetPolicies(&nat_true_);
 209   StopWatching();
 210 }
 211
 212 TEST_F(PolicyWatcherTest, NatNoneThenTrueThenTrue) {
 213   EXPECT_CALL(mock_policy_callback_,
 214               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 215
 216   StartWatching();
 217   policy_watcher_->SetPolicies(&empty_);
 218   policy_watcher_->SetPolicies(&nat_true_);
 219   policy_watcher_->SetPolicies(&nat_true_);
 220   StopWatching();
 221 }
 222
 223 TEST_F(PolicyWatcherTest, NatNoneThenTrueThenTrueThenFalse) {
 224   testing::InSequence sequence;
 225   EXPECT_CALL(mock_policy_callback_,
 226               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 227   EXPECT_CALL(mock_policy_callback_,
 228               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
 229
 230   StartWatching();
 231   policy_watcher_->SetPolicies(&empty_);
 232   policy_watcher_->SetPolicies(&nat_true_);
 233   policy_watcher_->SetPolicies(&nat_true_);
 234   policy_watcher_->SetPolicies(&nat_false_);
 235   StopWatching();
 236 }
 237
 238 TEST_F(PolicyWatcherTest, NatNoneThenFalse) {
 239   testing::InSequence sequence;
 240   EXPECT_CALL(mock_policy_callback_,
 241               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 242   EXPECT_CALL(mock_policy_callback_,
 243               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
 244
 245   StartWatching();
 246   policy_watcher_->SetPolicies(&empty_);
 247   policy_watcher_->SetPolicies(&nat_false_);
 248   StopWatching();
 249 }
 250
 251 TEST_F(PolicyWatcherTest, NatNoneThenFalseThenTrue) {
 252   testing::InSequence sequence;
 253   EXPECT_CALL(mock_policy_callback_,
 254               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 255   EXPECT_CALL(mock_policy_callback_,
 256               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
 257   EXPECT_CALL(mock_policy_callback_,
 258               OnPolicyUpdatePtr(IsPolicies(&nat_true_)));
 259
 260   StartWatching();
 261   policy_watcher_->SetPolicies(&empty_);
 262   policy_watcher_->SetPolicies(&nat_false_);
 263   policy_watcher_->SetPolicies(&nat_true_);
 264   StopWatching();
 265 }
 266
 267 TEST_F(PolicyWatcherTest, ChangeOneRepeatedlyThenTwo) {
 268   testing::InSequence sequence;
 269   EXPECT_CALL(mock_policy_callback_,
 270               OnPolicyUpdatePtr(IsPolicies(
 271                   &nat_true_domain_empty_others_default_)));
 272   EXPECT_CALL(mock_policy_callback_,
 273               OnPolicyUpdatePtr(IsPolicies(&domain_full_)));
 274   EXPECT_CALL(mock_policy_callback_,
 275               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
 276   EXPECT_CALL(mock_policy_callback_,
 277               OnPolicyUpdatePtr(IsPolicies(&domain_empty_)));
 278   EXPECT_CALL(mock_policy_callback_,
 279               OnPolicyUpdatePtr(IsPolicies(&nat_true_domain_full_)));
 280
 281   StartWatching();
 282   policy_watcher_->SetPolicies(&nat_true_domain_empty_);
 283   policy_watcher_->SetPolicies(&nat_true_domain_full_);
 284   policy_watcher_->SetPolicies(&nat_false_domain_full_);
 285   policy_watcher_->SetPolicies(&nat_false_domain_empty_);
 286   policy_watcher_->SetPolicies(&nat_true_domain_full_);
 287   StopWatching();
 288 }
 289
 290 TEST_F(PolicyWatcherTest, FilterUnknownPolicies) {
 291   testing::InSequence sequence;
 292   EXPECT_CALL(mock_policy_callback_,
 293               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 294
 295   StartWatching();
 296   policy_watcher_->SetPolicies(&empty_);
 297   policy_watcher_->SetPolicies(&unknown_policies_);
 298   policy_watcher_->SetPolicies(&empty_);
 299   StopWatching();
 300 }
 301
 302 TEST_F(PolicyWatcherTest, DebugOverrideNatPolicy) {
 303 #if !defined(NDEBUG)
 304   EXPECT_CALL(mock_policy_callback_,
 305       OnPolicyUpdatePtr(IsPolicies(&nat_false_overridden_others_default_)));
 306 #else
 307   EXPECT_CALL(mock_policy_callback_,
 308       OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 309 #endif
 310
 311   StartWatching();
 312   policy_watcher_->SetPolicies(&nat_true_and_overridden_);
 313   StopWatching();
 314 }
 315
 316 TEST_F(PolicyWatcherTest, PairingFalseThenTrue) {
 317   testing::InSequence sequence;
 318   EXPECT_CALL(mock_policy_callback_,
 319               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 320   EXPECT_CALL(mock_policy_callback_,
 321               OnPolicyUpdatePtr(IsPolicies(&pairing_false_)));
 322   EXPECT_CALL(mock_policy_callback_,
 323               OnPolicyUpdatePtr(IsPolicies(&pairing_true_)));
 324
 325   StartWatching();
 326   policy_watcher_->SetPolicies(&empty_);
 327   policy_watcher_->SetPolicies(&pairing_false_);
 328   policy_watcher_->SetPolicies(&pairing_true_);
 329   StopWatching();
 330 }
 331
 332 }  // namespace policy_hack
 333 }  // namespace remoting