1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <gtest/gtest.h> 6 7 #include "base/command_line.h" 8 #include "base/memory/ref_counted.h" 9 #include "base/strings/string_util.h" 10 #include "base/values.h" 11 #include "chrome/browser/prefs/command_line_pref_store.h" 12 #include "chrome/browser/prefs/proxy_config_dictionary.h" 13 #include "chrome/common/chrome_switches.h" 14 #include "chrome/common/pref_names.h" 15 #include "ui/base/ui_base_switches.h" 16 17 namespace { 18 19 const char unknown_bool[] = "unknown_switch"; 20 const char unknown_string[] = "unknown_other_switch"; 21 22 } // namespace 23 24 class TestCommandLinePrefStore : public CommandLinePrefStore { 25 public: 26 explicit TestCommandLinePrefStore(CommandLine* cl) 27 : CommandLinePrefStore(cl) {} 28 29 bool ProxySwitchesAreValid() { 30 return ValidateProxySwitches(); 31 } 32 33 void VerifyProxyMode(ProxyPrefs::ProxyMode expected_mode) { 34 const Value* value = NULL; 35 ASSERT_TRUE(GetValue(prefs::kProxy, &value)); 36 ASSERT_EQ(Value::TYPE_DICTIONARY, value->GetType()); 37 ProxyConfigDictionary dict(static_cast<const DictionaryValue*>(value)); 38 ProxyPrefs::ProxyMode actual_mode; 39 ASSERT_TRUE(dict.GetMode(&actual_mode)); 40 EXPECT_EQ(expected_mode, actual_mode); 41 } 42 43 void VerifySSLCipherSuites(const char* const* ciphers, 44 size_t cipher_count) { 45 const Value* value = NULL; 46 ASSERT_TRUE(GetValue(prefs::kCipherSuiteBlacklist, &value)); 47 ASSERT_EQ(Value::TYPE_LIST, value->GetType()); 48 const ListValue* list_value = static_cast<const ListValue*>(value); 49 ASSERT_EQ(cipher_count, list_value->GetSize()); 50 51 std::string cipher_string; 52 for (ListValue::const_iterator it = list_value->begin(); 53 it != list_value->end(); ++it, ++ciphers) { 54 ASSERT_TRUE((*it)->GetAsString(&cipher_string)); 55 EXPECT_EQ(*ciphers, cipher_string); 56 } 57 } 58 59 private: 60 virtual ~TestCommandLinePrefStore() {} 61 }; 62 63 // Tests a simple string pref on the command line. 64 TEST(CommandLinePrefStoreTest, SimpleStringPref) { 65 CommandLine cl(CommandLine::NO_PROGRAM); 66 cl.AppendSwitchASCII(switches::kLang, "hi-MOM"); 67 scoped_refptr<CommandLinePrefStore> store = new CommandLinePrefStore(&cl); 68 69 const Value* actual = NULL; 70 EXPECT_TRUE(store->GetValue(prefs::kApplicationLocale, &actual)); 71 std::string result; 72 EXPECT_TRUE(actual->GetAsString(&result)); 73 EXPECT_EQ("hi-MOM", result); 74 } 75 76 // Tests a simple boolean pref on the command line. 77 TEST(CommandLinePrefStoreTest, SimpleBooleanPref) { 78 CommandLine cl(CommandLine::NO_PROGRAM); 79 cl.AppendSwitch(switches::kNoProxyServer); 80 scoped_refptr<TestCommandLinePrefStore> store = 81 new TestCommandLinePrefStore(&cl); 82 83 store->VerifyProxyMode(ProxyPrefs::MODE_DIRECT); 84 } 85 86 // Tests a command line with no recognized prefs. 87 TEST(CommandLinePrefStoreTest, NoPrefs) { 88 CommandLine cl(CommandLine::NO_PROGRAM); 89 cl.AppendSwitch(unknown_string); 90 cl.AppendSwitchASCII(unknown_bool, "a value"); 91 scoped_refptr<CommandLinePrefStore> store = new CommandLinePrefStore(&cl); 92 93 const Value* actual = NULL; 94 EXPECT_FALSE(store->GetValue(unknown_bool, &actual)); 95 EXPECT_FALSE(store->GetValue(unknown_string, &actual)); 96 } 97 98 // Tests a complex command line with multiple known and unknown switches. 99 TEST(CommandLinePrefStoreTest, MultipleSwitches) { 100 CommandLine cl(CommandLine::NO_PROGRAM); 101 cl.AppendSwitch(unknown_string); 102 cl.AppendSwitchASCII(switches::kProxyServer, "proxy"); 103 cl.AppendSwitchASCII(switches::kProxyBypassList, "list"); 104 cl.AppendSwitchASCII(unknown_bool, "a value"); 105 scoped_refptr<TestCommandLinePrefStore> store = 106 new TestCommandLinePrefStore(&cl); 107 108 const Value* actual = NULL; 109 EXPECT_FALSE(store->GetValue(unknown_bool, &actual)); 110 EXPECT_FALSE(store->GetValue(unknown_string, &actual)); 111 112 store->VerifyProxyMode(ProxyPrefs::MODE_FIXED_SERVERS); 113 114 const Value* value = NULL; 115 ASSERT_TRUE(store->GetValue(prefs::kProxy, &value)); 116 ASSERT_EQ(Value::TYPE_DICTIONARY, value->GetType()); 117 ProxyConfigDictionary dict(static_cast<const DictionaryValue*>(value)); 118 119 std::string string_result; 120 121 ASSERT_TRUE(dict.GetProxyServer(&string_result)); 122 EXPECT_EQ("proxy", string_result); 123 124 ASSERT_TRUE(dict.GetBypassList(&string_result)); 125 EXPECT_EQ("list", string_result); 126 } 127 128 // Tests proxy switch validation. 129 TEST(CommandLinePrefStoreTest, ProxySwitchValidation) { 130 CommandLine cl(CommandLine::NO_PROGRAM); 131 132 // No switches. 133 scoped_refptr<TestCommandLinePrefStore> store = 134 new TestCommandLinePrefStore(&cl); 135 EXPECT_TRUE(store->ProxySwitchesAreValid()); 136 137 // Only no-proxy. 138 cl.AppendSwitch(switches::kNoProxyServer); 139 scoped_refptr<TestCommandLinePrefStore> store2 = 140 new TestCommandLinePrefStore(&cl); 141 EXPECT_TRUE(store2->ProxySwitchesAreValid()); 142 143 // Another proxy switch too. 144 cl.AppendSwitch(switches::kProxyAutoDetect); 145 scoped_refptr<TestCommandLinePrefStore> store3 = 146 new TestCommandLinePrefStore(&cl); 147 EXPECT_FALSE(store3->ProxySwitchesAreValid()); 148 149 // All proxy switches except no-proxy. 150 CommandLine cl2(CommandLine::NO_PROGRAM); 151 cl2.AppendSwitch(switches::kProxyAutoDetect); 152 cl2.AppendSwitchASCII(switches::kProxyServer, "server"); 153 cl2.AppendSwitchASCII(switches::kProxyPacUrl, "url"); 154 cl2.AppendSwitchASCII(switches::kProxyBypassList, "list"); 155 scoped_refptr<TestCommandLinePrefStore> store4 = 156 new TestCommandLinePrefStore(&cl2); 157 EXPECT_TRUE(store4->ProxySwitchesAreValid()); 158 } 159 160 TEST(CommandLinePrefStoreTest, ManualProxyModeInference) { 161 CommandLine cl1(CommandLine::NO_PROGRAM); 162 cl1.AppendSwitch(unknown_string); 163 cl1.AppendSwitchASCII(switches::kProxyServer, "proxy"); 164 scoped_refptr<TestCommandLinePrefStore> store1 = 165 new TestCommandLinePrefStore(&cl1); 166 store1->VerifyProxyMode(ProxyPrefs::MODE_FIXED_SERVERS); 167 168 CommandLine cl2(CommandLine::NO_PROGRAM); 169 cl2.AppendSwitchASCII(switches::kProxyPacUrl, "proxy"); 170 scoped_refptr<TestCommandLinePrefStore> store2 = 171 new TestCommandLinePrefStore(&cl2); 172 store2->VerifyProxyMode(ProxyPrefs::MODE_PAC_SCRIPT); 173 174 CommandLine cl3(CommandLine::NO_PROGRAM); 175 cl3.AppendSwitchASCII(switches::kProxyServer, std::string()); 176 scoped_refptr<TestCommandLinePrefStore> store3 = 177 new TestCommandLinePrefStore(&cl3); 178 store3->VerifyProxyMode(ProxyPrefs::MODE_DIRECT); 179 } 180 181 TEST(CommandLinePrefStoreTest, DisableSSLCipherSuites) { 182 CommandLine cl1(CommandLine::NO_PROGRAM); 183 cl1.AppendSwitchASCII(switches::kCipherSuiteBlacklist, 184 "0x0004,0x0005"); 185 scoped_refptr<TestCommandLinePrefStore> store1 = 186 new TestCommandLinePrefStore(&cl1); 187 const char* const expected_ciphers1[] = { 188 "0x0004", 189 "0x0005", 190 }; 191 store1->VerifySSLCipherSuites(expected_ciphers1, 192 arraysize(expected_ciphers1)); 193 194 CommandLine cl2(CommandLine::NO_PROGRAM); 195 cl2.AppendSwitchASCII(switches::kCipherSuiteBlacklist, 196 "0x0004, WHITESPACE_IGNORED TEST , 0x0005"); 197 scoped_refptr<TestCommandLinePrefStore> store2 = 198 new TestCommandLinePrefStore(&cl2); 199 const char* const expected_ciphers2[] = { 200 "0x0004", 201 "WHITESPACE_IGNORED TEST", 202 "0x0005", 203 }; 204 store2->VerifySSLCipherSuites(expected_ciphers2, 205 arraysize(expected_ciphers2)); 206 207 CommandLine cl3(CommandLine::NO_PROGRAM); 208 cl3.AppendSwitchASCII(switches::kCipherSuiteBlacklist, 209 "0x0004;MOAR;0x0005"); 210 scoped_refptr<TestCommandLinePrefStore> store3 = 211 new TestCommandLinePrefStore(&cl3); 212 const char* const expected_ciphers3[] = { 213 "0x0004;MOAR;0x0005" 214 }; 215 store3->VerifySSLCipherSuites(expected_ciphers3, 216 arraysize(expected_ciphers3)); 217 } 218
