Allow dynamic updating of authentication policies

net/http/http_auth_preferences_unittest.cc

Index: net/http/http_auth_preferences_unittest.cc
diff --git a/net/http/http_auth_preferences_unittest.cc b/net/http/http_auth_preferences_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..17b959dfe49b794854c5e84de999fb8433faa848
--- /dev/null
+++ b/net/http/http_auth_preferences_unittest.cc
@@ -0,0 +1,172 @@
+// 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 "net/http/http_auth_preferences.h"
+
+#include <string>
+#include <vector>
+#include "base/callback.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/testing_pref_service.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread.h"
+#include "net/base/net_pref_names.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+template <typename T>
+void CheckCall(T expected, base::Callback<T(void)> func) {
+  EXPECT_EQ(expected, func.Run());
+}
+
+}  // namespace
+
+namespace net {
+
+class HttpAuthPreferencesTest : public testing::Test {
+ protected:
+  HttpAuthPreferencesTest() : test_thread_("test thread") {
+    PrefRegistrySimple* pref_registry = pref_service_.registry();
+    HttpAuthPreferences::RegisterPrefs(pref_registry);
+    test_thread_.Start();
+  }
+
+  base::Thread test_thread_;
+  TestingPrefServiceSimple pref_service_;
+  HttpAuthPreferences http_auth_preferences_;
+
+  template <typename T>
+  void CheckValueOnTestThread(T expected, base::Callback<T(void)> func) {
+    base::RunLoop run_loop;
+    test_thread_.task_runner()->PostTaskAndReply(
+        FROM_HERE, base::Bind(&CheckCall<T>, expected, func),
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+};
+
+TEST_F(HttpAuthPreferencesTest, AuthSchemes) {
+  pref_service_.SetString(prefs::kAuthSchemes, "scheme1, scheme2");
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  const char* expected_schemes[] = {"scheme1", "scheme2"};
+  std::vector<std::string> expected_schemes_vector(
+      expected_schemes, expected_schemes + arraysize(expected_schemes));
+  // Check initial value
+  CheckValueOnTestThread(expected_schemes_vector,
+                         base::Bind(&HttpAuthPreferences::auth_schemes,
+                                    base::Unretained(&http_auth_preferences_)));
+  // Changes to the auth scheme list should be ignored
+  pref_service_.SetString(prefs::kAuthSchemes, "scheme3, scheme4");
+  CheckValueOnTestThread(expected_schemes_vector,
+                         base::Bind(&HttpAuthPreferences::auth_schemes,
+                                    base::Unretained(&http_auth_preferences_)));
+}
+
+TEST_F(HttpAuthPreferencesTest, DisableCnameLookup) {
+  pref_service_.SetBoolean(prefs::kDisableAuthNegotiateCnameLookup, false);
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  // Check initial value
+  CheckValueOnTestThread(
+      false, base::Bind(&HttpAuthPreferences::negotiate_disable_cname_lookup,
+                        base::Unretained(&http_auth_preferences_)));
+  // Check that the value changes when we change the preference
+  pref_service_.SetBoolean(prefs::kDisableAuthNegotiateCnameLookup, true);
+  CheckValueOnTestThread(
+      true, base::Bind(&HttpAuthPreferences::negotiate_disable_cname_lookup,
+                       base::Unretained(&http_auth_preferences_)));
+}
+
+TEST_F(HttpAuthPreferencesTest, NegotiateEnablePort) {
+  pref_service_.SetBoolean(prefs::kEnableAuthNegotiatePort, false);
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  // Check initial value
+  CheckValueOnTestThread(false,
+                         base::Bind(&HttpAuthPreferences::negotiate_enable_port,
+                                    base::Unretained(&http_auth_preferences_)));
+  // Check that the value changes when we change the preference
+  pref_service_.SetBoolean(prefs::kEnableAuthNegotiatePort, true);
+  CheckValueOnTestThread(true,
+                         base::Bind(&HttpAuthPreferences::negotiate_enable_port,
+                                    base::Unretained(&http_auth_preferences_)));
+}
+
+#if defined(OS_ANDROID)
+TEST_F(HttpAuthPreferencesTest, AuthAndroidhNegotiateAccountType) {
+  pref_service_.SetString(prefs::kAuthAndroidNegotiateAccountType, "abc");
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  // Check initial value
+  CheckValueOnTestThread(
+      std::string("abc"),
+      base::Bind(&HttpAuthPreferences::auth_android_negotiate_account_type,
+                 base::Unretained(&http_auth_preferences_)));
+  // Check that the value changes when we change the preference
+  pref_service_.SetString(prefs::kAuthAndroidNegotiateAccountType, "def");
+  CheckValueOnTestThread(
+      std::string("def"),
+      base::Bind(&HttpAuthPreferences::auth_android_negotiate_account_type,
+                 base::Unretained(&http_auth_preferences_)));
+}
+#endif
+
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
+TEST_F(HttpAuthPreferencesTest, GssApiLibraryName) {
+  pref_service_.SetString(prefs::kGSSAPILibraryName, "abc");
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  // Check initial value
+  CheckValueOnTestThread(std::string("abc"),
+                         base::Bind(&HttpAuthPreferences::gssapi_library_name,
+                                    base::Unretained(&http_auth_preferences_)));
+  // The value can't change after startup
+  pref_service_.SetString(prefs::kGSSAPILibraryName, "def");
+  CheckValueOnTestThread(std::string("abc"),
+                         base::Bind(&HttpAuthPreferences::gssapi_library_name,
+                                    base::Unretained(&http_auth_preferences_)));
+}
+#endif
+
+TEST_F(HttpAuthPreferencesTest, AuthServerWhitelist) {
+  pref_service_.SetString(prefs::kAuthServerWhitelist, "*");
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  // Check initial value
+  CheckValueOnTestThread(
+      true, base::Bind(&HttpAuthPreferences::CanUseDefaultCredentials,
+                       base::Unretained(&http_auth_preferences_), GURL("abc")));
+  // Check that the value changes when we change the preference
+  pref_service_.SetString(prefs::kAuthServerWhitelist, "xxx");
+  CheckValueOnTestThread(
+      false,
+      base::Bind(&HttpAuthPreferences::CanUseDefaultCredentials,
+                 base::Unretained(&http_auth_preferences_), GURL("abc")));
+  // Check an empty string
+  pref_service_.SetString(prefs::kAuthServerWhitelist, "");
+  CheckValueOnTestThread(
+      false,
+      base::Bind(&HttpAuthPreferences::CanUseDefaultCredentials,
+                 base::Unretained(&http_auth_preferences_), GURL("abc")));
+}
+
+TEST_F(HttpAuthPreferencesTest, AuthDelegateWhitelist) {
+  pref_service_.SetString(prefs::kAuthNegotiateDelegateWhitelist, "*");
+  http_auth_preferences_.Init(&pref_service_, test_thread_.task_runner());
+  // Check initial value
+  CheckValueOnTestThread(
+      true, base::Bind(&HttpAuthPreferences::CanDelegate,
+                       base::Unretained(&http_auth_preferences_), GURL("abc")));
+  // Check that the value changes when we change the preference
+  pref_service_.SetString(prefs::kAuthNegotiateDelegateWhitelist, "xxx");
+  CheckValueOnTestThread(
+      false,
+      base::Bind(&HttpAuthPreferences::CanDelegate,
+                 base::Unretained(&http_auth_preferences_), GURL("abc")));
+  // Check an empty string
+  pref_service_.SetString(prefs::kAuthNegotiateDelegateWhitelist, "");
+  CheckValueOnTestThread(
+      false,
+      base::Bind(&HttpAuthPreferences::CanDelegate,
+                 base::Unretained(&http_auth_preferences_), GURL("abc")));
+}
+
+}  // namespace net