Using PolicyServiceWatcher instead of PolicyWatcherLinux/Win/Mac.

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 <iostream>
+
 #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() {
-  }
+  PolicyWatcherTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
 
   void SetUp() override {
     message_loop_proxy_ = base::MessageLoopProxy::current();
     policy_updated_callback_ = base::Bind(
         &MockPolicyCallback::OnPolicyUpdate,
         base::Unretained(&mock_policy_callback_));
     policy_error_callback_ = base::Bind(
         &MockPolicyCallback::OnPolicyError,
         base::Unretained(&mock_policy_callback_));
     policy_watcher_.reset(new FakePolicyWatcher(message_loop_proxy_));
@@ skipping 407 matching lines @@
   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();
 }
 
+// Unit tests cannot instantiate PolicyWatcher on ChromeOS
+// (as this requires running inside a browser process).

[Mattias Nissler (ping if slow), 2015/01/06 09:06:12]

You could create a fake PolicyService and test against that perhaps?

[Łukasz Anforowicz, 2015/01/07 17:54:15]

If PolicyServiceWatcher is here for the long term, then I definitely need/want
to add unit tests (mostly for its logic that deals with translating a PolicyMap
into a DictionaryValue, but maybe for the update/initialized callbacks logic as
well).  For now - I am not sure if PolicyServiceWatcher will stay (i.e. maybe we
should replace DictionaryValue with passing a thread-safe PolicyMap instead). 
Also - the code for translating PolicyMap into DictionaryValue has already
existed in PolicyWatcherChromeOS before my changes (and it didn't have unit
tests), so I am not making things any worse in this changelist.

[Mattias Nissler (ping if slow), 2015/01/08 09:58:36]

OK, fair enough.

+#ifndef OS_CHROMEOS
+
+namespace {
+
+void OnPolicyUpdatedDumpPolicy(scoped_ptr<base::DictionaryValue> policies) {
+  if (!VLOG_IS_ON(1)) {
+    return;
+  }
+
+  std::cout << "OnPolicyUpdated callback received the following policies:"
+            << std::endl;
+
+  for (base::DictionaryValue::Iterator iter(*policies); !iter.IsAtEnd();
+       iter.Advance()) {
+    std::cout << iter.key() << " = ";
+    switch (iter.value().GetType()) {
+      case base::Value::Type::TYPE_STRING: {
+        std::string value;
+        CHECK(iter.value().GetAsString(&value));
+        std::cout << "string: " << '"' << value << '"';
+        break;
+      }
+      case base::Value::Type::TYPE_BOOLEAN: {
+        bool value;
+        CHECK(iter.value().GetAsBoolean(&value));
+        std::cout << "boolean: " << (value ? "True" : "False");
+        break;
+      }
+      default: {
+        std::cout << "unrecognized type";
+        break;
+      }
+    }
+    std::cout << std::endl;
+  }
+}
+
+}  // anonymous namespace
+
+// To dump policy contents, run unit tests with the following flags:
+// --gtest_filter=*TestRealChromotingPolicy* -v=1
+TEST_F(PolicyWatcherTest, TestRealChromotingPolicy) {
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      base::MessageLoop::current()->task_runner();
+  scoped_ptr<PolicyWatcher> policy_watcher(
+      PolicyWatcher::Create(nullptr, task_runner));
+
+  {
+    base::RunLoop run_loop;
+    policy_watcher->StartWatching(base::Bind(OnPolicyUpdatedDumpPolicy),
+                                  base::Bind(base::DoNothing));
+    run_loop.RunUntilIdle();
+  }
+
+  {
+    base::RunLoop run_loop;
+    PolicyWatcher* raw_policy_watcher = policy_watcher.release();
+    raw_policy_watcher->StopWatching(
+        base::Bind(base::IgnoreResult(
+                       &base::SequencedTaskRunner::DeleteSoon<PolicyWatcher>),
+                   task_runner, FROM_HERE, raw_policy_watcher));
+    run_loop.RunUntilIdle();
+  }
+
+  // Today, the only verification offered by this test is:
+  // - Manual verification of policy values dumped by OnPolicyUpdatedDumpPolicy
+  // - Automated verification that nothing crashed

[Mattias Nissler (ping if slow), 2015/01/06 09:06:12]

It may make sense to add a test that tests PolicyServiceWatcher against a fake
ConfigurationPolicyProvider?

[Łukasz Anforowicz, 2015/01/07 17:54:15]

Yes, but see my other comment for explanation why I didn't do it in the current
changelist.

Also - the new test is still useful - it let's me do ad-hoc/manual validation of
the values present on my Linux/Mac/Windows + it at least proves that the
actual/concrete readers + PolicyServiceWatcher do not crash when reading an
actual policy.

[Mattias Nissler (ping if slow), 2015/01/08 09:58:36]

OK, might still want to document proposed improvements in the comment.

[Łukasz Anforowicz, 2015/01/08 23:09:26]

I thought about it and the test against a MockConfigurationPolicyProvider will
be useful in the long-term even if PolicyServiceWatcher goes away (that might
mean the test has to be refactored, but this is true for the other already
existing tests as well).   OTOH, I think I'll keep the current changelist as-is
(it just preserves the test coverage we have today) and try to add the test in
the future.  I've actually tried adding this test today but backed out because
1) it forces changes to the interface of PolicyServiceWatcher (to expose
CreateFromPolicyLoader + GetChromotingPolicyNamespace) and 2) I am not sure if I
want to test via the existing MockConfigurationPolicyProvider VS new
FakeAsyncPolicyLoader (the latter one will give me slightly more coverage,
especially around which schema gets used by PolicyServiceWatcher) and 3) the
test got quite big after I had to debug some silly mistakes and added full-blown
dictionary matcher for GMock.

+}
+
+#endif
+
 }  // namespace policy_hack
 }  // namespace remoting