Restart the host when the third party auth certificate changes

remoting/host/linux/certificate_watcher_unittest.cc

+// Copyright 2016 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 "remoting/host/linux/certificate_watcher.h"
+
+#include <cstdlib>
+#include <string>
+
+#include "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "remoting/base/auto_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace remoting {
+
+const char kWatchFileName[] = "testfile.txt";
+
+const int kMessageLoopWaitMsecs = 150;
+
+class CertificateWatcherTest : public testing::Test {
+ public:
+  CertificateWatcherTest()
+      : task_runner_(message_loop_.task_runner()),
+        watch_path_(CreateAndGetUniqueTempDir().AppendASCII(kWatchFileName)),
+        watcher_(base::Bind(&CertificateWatcherTest::OnRestart,
+                            base::Unretained(this)),
+                 task_runner_) {
+    watcher_.SetDelayForTests(base::TimeDelta::FromSeconds(0));
+    watcher_.SetWatchPathForTests(watch_path_);
+  }
+
+ protected:
+  // Call this if you expect a restart after the loop runs.
+  // The thread will hang if OnRestart is never called.
+  void RunLoop() {
+    message_loop_.Run();
+  }
+
+  // Call this if you expect no restart after the loop runs.
+  // Will quit the loop after kMessageLoopWaitMsecs.
+  void RunAndWait() {
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&base::MessageLoopForIO::QuitNow,
+                   base::Unretained(&message_loop_)),
+        loop_wait_);
+    message_loop_.Run();
+  }
+
+  bool Start() {
+    return watcher_.Start();
+  }
+
+  void Connect() {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&CertificateWatcher::OnClientConnected,
+                   base::Unretained(&watcher_), ""));
+  }
+
+  void Disconnect() {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&CertificateWatcher::OnClientDisconnected,
+                   base::Unretained(&watcher_), ""));
+  }
+
+  void TouchFile() {
+    task_runner_->PostTask(
+              FROM_HERE, base::Bind(&CertificateWatcherTest::TouchFileTask,
+                                    base::Unretained(this)));
+  }
+
+  void TouchFileTask() {
+    std::string testWriteString = std::to_string(rand());
+
+    base::WriteFile(watch_path_, testWriteString.c_str(),
+                    testWriteString.length());
+  }
+
+  base::MessageLoopForIO message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  base::ScopedTempDir temp_dir_;
+  base::FilePath watch_path_;
+  CertificateWatcher watcher_;
+  int restart_count_ = 0;
+  base::TimeDelta loop_wait_ =
+      base::TimeDelta::FromMilliseconds(kMessageLoopWaitMsecs);
+
+ private:
+  const base::FilePath& CreateAndGetUniqueTempDir() {
+    EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
+    return temp_dir_.path();
+  }
+
+  void OnRestart() {
+    restart_count_++;
+    message_loop_.QuitNow();
+  }
+};
+
+TEST_F(CertificateWatcherTest, OneTouch) {
+  EXPECT_EQ(0, restart_count_);
+  EXPECT_TRUE(Start());
+  EXPECT_EQ(0, restart_count_);
+  TouchFile();
+  RunLoop();
+  EXPECT_EQ(1, restart_count_);
+}
+
+TEST_F(CertificateWatcherTest, InhibitDeferRestart) {
+  EXPECT_TRUE(Start());
+  EXPECT_EQ(0, restart_count_);
+  Connect();
+  EXPECT_EQ(0, restart_count_);
+  TouchFile();
+  RunAndWait();
+  EXPECT_EQ(0, restart_count_);
+  Disconnect();
+  RunLoop();
+  EXPECT_EQ(1, restart_count_);
+}
+
+TEST_F(CertificateWatcherTest, UninhibitAndRestart) {
+  EXPECT_TRUE(Start());
+  EXPECT_EQ(0, restart_count_);
+  Connect();
+  EXPECT_EQ(0, restart_count_);
+  Disconnect();
+  RunAndWait();
+  EXPECT_EQ(0, restart_count_);
+  TouchFile();
+  RunLoop();
+  EXPECT_EQ(1, restart_count_);
+}
+
+TEST_F(CertificateWatcherTest, EmptyPathFailToStart) {
+  // Covers the case when base::PathService::Get(base::DIR_HOME, ...) fails
+  watcher_.SetWatchPathForTests(base::FilePath());
+  EXPECT_FALSE(Start());
+}
+
+} // namespace remoting