| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/basictypes.h" |
| #include "base/bind.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/run_loop.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "remoting/host/dns_blackhole_checker.h" |
| #include "remoting/host/policy_hack/fake_policy_watcher.h" |
| #include "remoting/host/policy_hack/mock_policy_callback.h" |
| #include "remoting/host/policy_hack/policy_watcher.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace remoting { |
| namespace policy_hack { |
| |
| class PolicyWatcherTest : public testing::Test { |
| public: |
| PolicyWatcherTest() { |
| } |
| |
| virtual void SetUp() OVERRIDE { |
| message_loop_proxy_ = base::MessageLoopProxy::current(); |
| policy_callback_ = base::Bind(&MockPolicyCallback::OnPolicyUpdate, |
| base::Unretained(&mock_policy_callback_)); |
| policy_watcher_.reset(new FakePolicyWatcher(message_loop_proxy_)); |
| nat_true_.SetBoolean(PolicyWatcher::kNatPolicyName, true); |
| nat_false_.SetBoolean(PolicyWatcher::kNatPolicyName, false); |
| nat_one_.SetInteger(PolicyWatcher::kNatPolicyName, 1); |
| domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| std::string()); |
| domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName, kHostDomain); |
| SetDefaults(nat_true_others_default_); |
| nat_true_others_default_.SetBoolean(PolicyWatcher::kNatPolicyName, true); |
| SetDefaults(nat_false_others_default_); |
| nat_false_others_default_.SetBoolean(PolicyWatcher::kNatPolicyName, false); |
| SetDefaults(domain_empty_others_default_); |
| domain_empty_others_default_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| std::string()); |
| SetDefaults(domain_full_others_default_); |
| domain_full_others_default_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| kHostDomain); |
| nat_true_domain_empty_.SetBoolean(PolicyWatcher::kNatPolicyName, true); |
| nat_true_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| std::string()); |
| nat_true_domain_full_.SetBoolean(PolicyWatcher::kNatPolicyName, true); |
| nat_true_domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| kHostDomain); |
| nat_false_domain_empty_.SetBoolean(PolicyWatcher::kNatPolicyName, false); |
| nat_false_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| std::string()); |
| nat_false_domain_full_.SetBoolean(PolicyWatcher::kNatPolicyName, false); |
| nat_false_domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName, |
| kHostDomain); |
| SetDefaults(nat_true_domain_empty_others_default_); |
| nat_true_domain_empty_others_default_.SetBoolean( |
| PolicyWatcher::kNatPolicyName, true); |
| nat_true_domain_empty_others_default_.SetString( |
| PolicyWatcher::kHostDomainPolicyName, std::string()); |
| unknown_policies_.SetString("UnknownPolicyOne", std::string()); |
| unknown_policies_.SetString("UnknownPolicyTwo", std::string()); |
| |
| const char kOverrideNatTraversalToFalse[] = |
| "{ \"RemoteAccessHostFirewallTraversal\": false }"; |
| nat_true_and_overridden_.SetBoolean(PolicyWatcher::kNatPolicyName, true); |
| nat_true_and_overridden_.SetString( |
| PolicyWatcher::kHostDebugOverridePoliciesName, |
| kOverrideNatTraversalToFalse); |
| pairing_true_.SetBoolean(PolicyWatcher::kHostAllowClientPairing, true); |
| pairing_false_.SetBoolean(PolicyWatcher::kHostAllowClientPairing, false); |
| gnubby_auth_true_.SetBoolean(PolicyWatcher::kHostAllowGnubbyAuthPolicyName, |
| true); |
| gnubby_auth_false_.SetBoolean(PolicyWatcher::kHostAllowGnubbyAuthPolicyName, |
| false); |
| relay_true_.SetBoolean(PolicyWatcher::kRelayPolicyName, true); |
| relay_false_.SetBoolean(PolicyWatcher::kRelayPolicyName, false); |
| port_range_full_.SetString(PolicyWatcher::kUdpPortRangePolicyName, |
| kPortRange); |
| port_range_empty_.SetString(PolicyWatcher::kUdpPortRangePolicyName, |
| std::string()); |
| |
| #if !defined(NDEBUG) |
| SetDefaults(nat_false_overridden_others_default_); |
| nat_false_overridden_others_default_.SetBoolean( |
| PolicyWatcher::kNatPolicyName, false); |
| nat_false_overridden_others_default_.SetString( |
| PolicyWatcher::kHostDebugOverridePoliciesName, |
| kOverrideNatTraversalToFalse); |
| #endif |
| } |
| |
| protected: |
| void StartWatching() { |
| policy_watcher_->StartWatching(policy_callback_); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| void StopWatching() { |
| base::WaitableEvent stop_event(false, false); |
| policy_watcher_->StopWatching(&stop_event); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(true, stop_event.IsSignaled()); |
| } |
| |
| static const char* kHostDomain; |
| static const char* kPortRange; |
| base::MessageLoop message_loop_; |
| scoped_refptr<base::MessageLoopProxy> message_loop_proxy_; |
| MockPolicyCallback mock_policy_callback_; |
| PolicyWatcher::PolicyCallback policy_callback_; |
| scoped_ptr<FakePolicyWatcher> policy_watcher_; |
| base::DictionaryValue empty_; |
| base::DictionaryValue nat_true_; |
| base::DictionaryValue nat_false_; |
| base::DictionaryValue nat_one_; |
| base::DictionaryValue domain_empty_; |
| base::DictionaryValue domain_full_; |
| base::DictionaryValue nat_true_others_default_; |
| base::DictionaryValue nat_false_others_default_; |
| base::DictionaryValue domain_empty_others_default_; |
| base::DictionaryValue domain_full_others_default_; |
| base::DictionaryValue nat_true_domain_empty_; |
| base::DictionaryValue nat_true_domain_full_; |
| base::DictionaryValue nat_false_domain_empty_; |
| base::DictionaryValue nat_false_domain_full_; |
| base::DictionaryValue nat_true_domain_empty_others_default_; |
| base::DictionaryValue unknown_policies_; |
| base::DictionaryValue nat_true_and_overridden_; |
| base::DictionaryValue nat_false_overridden_others_default_; |
| base::DictionaryValue pairing_true_; |
| base::DictionaryValue pairing_false_; |
| base::DictionaryValue gnubby_auth_true_; |
| base::DictionaryValue gnubby_auth_false_; |
| base::DictionaryValue relay_true_; |
| base::DictionaryValue relay_false_; |
| base::DictionaryValue port_range_full_; |
| base::DictionaryValue port_range_empty_; |
| |
| private: |
| void SetDefaults(base::DictionaryValue& dict) { |
| dict.SetBoolean(PolicyWatcher::kNatPolicyName, true); |
| dict.SetBoolean(PolicyWatcher::kRelayPolicyName, true); |
| dict.SetString(PolicyWatcher::kUdpPortRangePolicyName, ""); |
| dict.SetBoolean(PolicyWatcher::kHostRequireTwoFactorPolicyName, false); |
| dict.SetString(PolicyWatcher::kHostDomainPolicyName, std::string()); |
| dict.SetBoolean(PolicyWatcher::kHostMatchUsernamePolicyName, false); |
| dict.SetString(PolicyWatcher::kHostTalkGadgetPrefixPolicyName, |
| kDefaultHostTalkGadgetPrefix); |
| dict.SetBoolean(PolicyWatcher::kHostRequireCurtainPolicyName, false); |
| dict.SetString(PolicyWatcher::kHostTokenUrlPolicyName, std::string()); |
| dict.SetString(PolicyWatcher::kHostTokenValidationUrlPolicyName, |
| std::string()); |
| dict.SetString(PolicyWatcher::kHostTokenValidationCertIssuerPolicyName, |
| std::string()); |
| dict.SetBoolean(PolicyWatcher::kHostAllowClientPairing, true); |
| dict.SetBoolean(PolicyWatcher::kHostAllowGnubbyAuthPolicyName, true); |
| #if !defined(NDEBUG) |
| dict.SetString(PolicyWatcher::kHostDebugOverridePoliciesName, ""); |
| #endif |
| } |
| }; |
| |
| const char* PolicyWatcherTest::kHostDomain = "google.com"; |
| const char* PolicyWatcherTest::kPortRange = "12400-12409"; |
| |
| MATCHER_P(IsPolicies, dict, "") { |
| return arg->Equals(dict); |
| } |
| |
| TEST_F(PolicyWatcherTest, None) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatTrue) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&nat_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatFalse) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&nat_false_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatOne) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&nat_one_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, DomainEmpty) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&domain_empty_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&domain_empty_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, DomainFull) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&domain_full_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&domain_full_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatNoneThenTrue) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&nat_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatNoneThenTrueThenTrue) { |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&nat_true_); |
| policy_watcher_->SetPolicies(&nat_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatNoneThenTrueThenTrueThenFalse) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&nat_true_); |
| policy_watcher_->SetPolicies(&nat_true_); |
| policy_watcher_->SetPolicies(&nat_false_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatNoneThenFalse) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&nat_false_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, NatNoneThenFalseThenTrue) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&nat_false_); |
| policy_watcher_->SetPolicies(&nat_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, ChangeOneRepeatedlyThenTwo) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies( |
| &nat_true_domain_empty_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&domain_full_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&domain_empty_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_domain_full_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&nat_true_domain_empty_); |
| policy_watcher_->SetPolicies(&nat_true_domain_full_); |
| policy_watcher_->SetPolicies(&nat_false_domain_full_); |
| policy_watcher_->SetPolicies(&nat_false_domain_empty_); |
| policy_watcher_->SetPolicies(&nat_true_domain_full_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, FilterUnknownPolicies) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&unknown_policies_); |
| policy_watcher_->SetPolicies(&empty_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, DebugOverrideNatPolicy) { |
| #if !defined(NDEBUG) |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_false_overridden_others_default_))); |
| #else |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| #endif |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&nat_true_and_overridden_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, PairingFalseThenTrue) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&pairing_false_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&pairing_true_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&pairing_false_); |
| policy_watcher_->SetPolicies(&pairing_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, GnubbyAuth) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&gnubby_auth_false_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&gnubby_auth_true_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&gnubby_auth_false_); |
| policy_watcher_->SetPolicies(&gnubby_auth_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, Relay) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&relay_false_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&relay_true_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&relay_false_); |
| policy_watcher_->SetPolicies(&relay_true_); |
| StopWatching(); |
| } |
| |
| TEST_F(PolicyWatcherTest, UdpPortRange) { |
| testing::InSequence sequence; |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&port_range_full_))); |
| EXPECT_CALL(mock_policy_callback_, |
| OnPolicyUpdatePtr(IsPolicies(&port_range_empty_))); |
| |
| StartWatching(); |
| policy_watcher_->SetPolicies(&empty_); |
| policy_watcher_->SetPolicies(&port_range_full_); |
| policy_watcher_->SetPolicies(&port_range_empty_); |
| StopWatching(); |
| } |
| |
| } // namespace policy_hack |
| } // namespace remoting |