Reporting of policy errors via host-offline-reason: part 1

remoting/host/policy_hack/policy_watcher_unittest.cc

 // 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,
+    policy_updated_callback_ = base::Bind(&MockPolicyCallback::OnPolicyUpdate,
+                                  base::Unretained(&mock_policy_callback_));

[Lambros, 2014/11/14 01:42:47]

nit: Wrong indentation. Should line up with first param, or +4 against previous
line.

[Łukasz Anforowicz, 2014/11/14 03:17:18]

Ah, right.  I was doing a search & replace of policy_callback ->
policy_updated_callback and that broke the indentation :-)

+    policy_error_callback_ = base::Bind(&MockPolicyCallback::OnPolicyError,
                                   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);
@@ skipping 49 matching lines @@
     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_);
+    policy_watcher_->StartWatching(
+        policy_updated_callback_,
+        policy_error_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_;
+  PolicyWatcher::PolicyUpdatedCallback policy_updated_callback_;
+  PolicyWatcher::PolicyErrorCallback policy_error_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_;
@@ skipping 271 matching lines @@
   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();
 }
 
+const int kMaxTransientErrorRetries = 5;
+
+TEST_F(PolicyWatcherTest, SingleTransientErrorDoesntTriggerErrorCallback) {
+  EXPECT_CALL(mock_policy_callback_, OnPolicyErrorPtr()).Times(0);
+
+  StartWatching();
+  policy_watcher_->SignalTransientErrorForTest();
+  StopWatching();
+}
+
+TEST_F(PolicyWatcherTest, MultipleTransientErrorsTriggerErrorCallback) {
+  EXPECT_CALL(mock_policy_callback_, OnPolicyErrorPtr());
+
+  StartWatching();
+  for (int i = 0; i < kMaxTransientErrorRetries; i++) {
+    policy_watcher_->SignalTransientErrorForTest();
+  }
+  StopWatching();
+}
+
+TEST_F(PolicyWatcherTest, PolicyUpdateResetsTransientErrorsCounter) {
+  testing::InSequence s;
+  EXPECT_CALL(mock_policy_callback_,
+              OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
+  EXPECT_CALL(mock_policy_callback_, OnPolicyErrorPtr()).Times(0);
+
+  StartWatching();
+  for (int i = 0; i < (kMaxTransientErrorRetries - 1); i++) {
+    policy_watcher_->SignalTransientErrorForTest();
+  }
+  policy_watcher_->SetPolicies(&nat_true_);
+  for (int i = 0; i < (kMaxTransientErrorRetries - 1); i++) {
+    policy_watcher_->SignalTransientErrorForTest();
+  }
+  StopWatching();
+}
+
 }  // namespace policy_hack
 }  // namespace remoting