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 "chrome/browser/chromeos/proxy_config_service_impl.h"
6
7#include <vector>
8
9#include "base/format_macros.h"
10#include "base/json/json_writer.h"
11#include "base/logging.h"
12#include "base/message_loop/message_loop.h"
13#include "base/prefs/testing_pref_service.h"
14#include "base/strings/stringprintf.h"
15#include "chrome/browser/chromeos/settings/cros_settings.h"
16#include "chrome/browser/chromeos/settings/device_settings_service.h"
17#include "chrome/browser/chromeos/ui_proxy_config.h"
18#include "chrome/common/pref_names.h"
19#include "chromeos/dbus/dbus_thread_manager.h"
20#include "chromeos/dbus/shill_profile_client.h"
21#include "chromeos/dbus/shill_service_client.h"
22#include "chromeos/network/network_handler.h"
23#include "chromeos/network/network_state.h"
24#include "chromeos/network/network_state_handler.h"
25#include "content/public/test/test_browser_thread.h"
26#include "net/proxy/proxy_config_service_common_unittest.h"
27#include "testing/gtest/include/gtest/gtest.h"
28#include "third_party/cros_system_api/dbus/service_constants.h"
29
30using content::BrowserThread;
31
32namespace chromeos {
33
34namespace {
35
36struct Input {
37  UIProxyConfig::Mode mode;
38  std::string pac_url;
39  std::string server;
40  std::string bypass_rules;
41};
42
43// Builds an identifier for each test in an array.
44#define TEST_DESC(desc) base::StringPrintf("at line %d <%s>", __LINE__, desc)
45
46// Shortcuts to declare enums within chromeos's ProxyConfig.
47#define MK_MODE(mode) UIProxyConfig::MODE_##mode
48
49// Inspired from net/proxy/proxy_config_service_linux_unittest.cc.
50const struct TestParams {
51  // Short description to identify the test
52  std::string description;
53
54  Input input;
55
56  // Expected outputs from fields of net::ProxyConfig (via IO).
57  bool auto_detect;
58  GURL pac_url;
59  net::ProxyRulesExpectation proxy_rules;
60} tests[] = {
61  {  // 0
62    TEST_DESC("No proxying"),
63
64    { // Input.
65      MK_MODE(DIRECT),  // mode
66    },
67
68    // Expected result.
69    false,                                   // auto_detect
70    GURL(),                                  // pac_url
71    net::ProxyRulesExpectation::Empty(),     // proxy_rules
72  },
73
74  {  // 1
75    TEST_DESC("Auto detect"),
76
77    { // Input.
78      MK_MODE(AUTO_DETECT),  // mode
79    },
80
81    // Expected result.
82    true,                                    // auto_detect
83    GURL(),                                  // pac_url
84    net::ProxyRulesExpectation::Empty(),     // proxy_rules
85  },
86
87  {  // 2
88    TEST_DESC("Valid PAC URL"),
89
90    { // Input.
91      MK_MODE(PAC_SCRIPT),     // mode
92      "http://wpad/wpad.dat",  // pac_url
93    },
94
95    // Expected result.
96    false,                                   // auto_detect
97    GURL("http://wpad/wpad.dat"),            // pac_url
98    net::ProxyRulesExpectation::Empty(),     // proxy_rules
99  },
100
101  {  // 3
102    TEST_DESC("Invalid PAC URL"),
103
104    { // Input.
105      MK_MODE(PAC_SCRIPT),  // mode
106      "wpad.dat",           // pac_url
107    },
108
109    // Expected result.
110    false,                                   // auto_detect
111    GURL(),                                  // pac_url
112    net::ProxyRulesExpectation::Empty(),     // proxy_rules
113  },
114
115  {  // 4
116    TEST_DESC("Single-host in proxy list"),
117
118    { // Input.
119      MK_MODE(SINGLE_PROXY),  // mode
120      "",                     // pac_url
121      "www.google.com",       // server
122    },
123
124    // Expected result.
125    false,                                   // auto_detect
126    GURL(),                                  // pac_url
127    net::ProxyRulesExpectation::Single(      // proxy_rules
128        "www.google.com:80",                 // single proxy
129        "<local>"),                          // bypass rules
130  },
131
132  {  // 5
133    TEST_DESC("Single-host, different port"),
134
135    { // Input.
136      MK_MODE(SINGLE_PROXY),  // mode
137      "",                     // pac_url
138      "www.google.com:99",    // server
139    },
140
141    // Expected result.
142    false,                                   // auto_detect
143    GURL(),                                  // pac_url
144    net::ProxyRulesExpectation::Single(      // proxy_rules
145        "www.google.com:99",                 // single
146        "<local>"),                          // bypass rules
147  },
148
149  {  // 6
150    TEST_DESC("Tolerate a scheme"),
151
152    { // Input.
153      MK_MODE(SINGLE_PROXY),       // mode
154      "",                          // pac_url
155      "http://www.google.com:99",  // server
156    },
157
158    // Expected result.
159    false,                                   // auto_detect
160    GURL(),                                  // pac_url
161    net::ProxyRulesExpectation::Single(      // proxy_rules
162        "www.google.com:99",                 // single proxy
163        "<local>"),                          // bypass rules
164  },
165
166  {  // 7
167    TEST_DESC("Per-scheme proxy rules"),
168
169    { // Input.
170      MK_MODE(PROXY_PER_SCHEME),  // mode
171      "",                         // pac_url
172      "http=www.google.com:80;https=https://www.foo.com:110;"
173      "ftp=ftp.foo.com:121;socks=socks5://socks.com:888",  // server
174    },
175
176    // Expected result.
177    false,                          // auto_detect
178    GURL(),                         // pac_url
179    net::ProxyRulesExpectation::PerSchemeWithSocks(  // proxy_rules
180        "www.google.com:80",        // http
181        "https://www.foo.com:110",  // https
182        "ftp.foo.com:121",          // ftp
183        "socks5://socks.com:888",   // fallback proxy
184        "<local>"),                 // bypass rules
185  },
186
187  {  // 8
188    TEST_DESC("Bypass rules"),
189
190    { // Input.
191      MK_MODE(SINGLE_PROXY),      // mode
192      "",                         // pac_url
193      "www.google.com",           // server
194      "*.google.com, *foo.com:99, 1.2.3.4:22, 127.0.0.1/8",  // bypass_rules
195    },
196
197    // Expected result.
198    false,                          // auto_detect
199    GURL(),                         // pac_url
200    net::ProxyRulesExpectation::Single(  // proxy_rules
201        "www.google.com:80",             // single proxy
202        // bypass_rules
203        "*.google.com,*foo.com:99,1.2.3.4:22,127.0.0.1/8,<local>"),
204  },
205};  // tests
206
207const char* kUserProfilePath = "user_profile";
208
209}  // namespace
210
211class ProxyConfigServiceImplTest : public testing::Test {
212 protected:
213  ProxyConfigServiceImplTest()
214      : ui_thread_(BrowserThread::UI, &loop_),
215        io_thread_(BrowserThread::IO, &loop_) {}
216
217  virtual void SetUp() {
218    DBusThreadManager::Initialize();
219    NetworkHandler::Initialize();
220
221    SetUpNetwork();
222
223    PrefProxyConfigTrackerImpl::RegisterPrefs(pref_service_.registry());
224
225    // Create a ProxyConfigServiceImpl like for the system request context.
226    config_service_impl_.reset(
227        new ProxyConfigServiceImpl(NULL,  // no profile prefs
228                                   &pref_service_));
229    proxy_config_service_ =
230        config_service_impl_->CreateTrackingProxyConfigService(
231            scoped_ptr<net::ProxyConfigService>());
232
233    // CreateTrackingProxyConfigService triggers update of initial prefs proxy
234    // config by tracker to chrome proxy config service, so flush all pending
235    // tasks so that tests start fresh.
236    loop_.RunUntilIdle();
237  }
238
239  void SetUpNetwork() {
240    ShillProfileClient::TestInterface* profile_test =
241        DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
242    ShillServiceClient::TestInterface* service_test =
243        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
244
245    // Process any pending notifications before clearing services.
246    loop_.RunUntilIdle();
247    service_test->ClearServices();
248
249    // Sends a notification about the added profile.
250    profile_test->AddProfile(kUserProfilePath, "user_hash");
251
252    service_test->AddService("/service/stub_wifi2",
253                             "stub_wifi2" /* guid */,
254                             "wifi2_PSK",
255                             shill::kTypeWifi, shill::kStateOnline,
256                             true /* visible */);
257    profile_test->AddService(kUserProfilePath, "/service/stub_wifi2");
258
259    loop_.RunUntilIdle();
260  }
261
262  virtual void TearDown() {
263    config_service_impl_->DetachFromPrefService();
264    loop_.RunUntilIdle();
265    config_service_impl_.reset();
266    proxy_config_service_.reset();
267    NetworkHandler::Shutdown();
268    DBusThreadManager::Shutdown();
269  }
270
271  void InitConfigWithTestInput(const Input& input,
272                               base::DictionaryValue* result) {
273    base::DictionaryValue* new_config = NULL;
274    switch (input.mode) {
275      case MK_MODE(DIRECT):
276        new_config = ProxyConfigDictionary::CreateDirect();
277        break;
278      case MK_MODE(AUTO_DETECT):
279        new_config = ProxyConfigDictionary::CreateAutoDetect();
280        break;
281      case MK_MODE(PAC_SCRIPT):
282        new_config =
283            ProxyConfigDictionary::CreatePacScript(input.pac_url, false);
284        break;
285      case MK_MODE(SINGLE_PROXY):
286      case MK_MODE(PROXY_PER_SCHEME):
287        new_config =
288          ProxyConfigDictionary::CreateFixedServers(input.server,
289                                                    input.bypass_rules);
290        break;
291    }
292    result->Swap(new_config);
293    delete new_config;
294  }
295
296  void SetConfig(base::DictionaryValue* pref_proxy_config_dict) {
297    std::string proxy_config;
298    if (pref_proxy_config_dict)
299      base::JSONWriter::Write(pref_proxy_config_dict, &proxy_config);
300
301    NetworkStateHandler* network_state_handler =
302        NetworkHandler::Get()->network_state_handler();
303    const NetworkState* network = network_state_handler->DefaultNetwork();
304    ASSERT_TRUE(network);
305    DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()->
306        SetServiceProperty(network->path(),
307                           shill::kProxyConfigProperty,
308                           base::StringValue(proxy_config));
309  }
310
311  // Synchronously gets the latest proxy config.
312  void SyncGetLatestProxyConfig(net::ProxyConfig* config) {
313    *config = net::ProxyConfig();
314    // Let message loop process all messages. This will run
315    // ChromeProxyConfigService::UpdateProxyConfig, which is posted on IO from
316    // PrefProxyConfigTrackerImpl::OnProxyConfigChanged.
317    loop_.RunUntilIdle();
318    net::ProxyConfigService::ConfigAvailability availability =
319        proxy_config_service_->GetLatestProxyConfig(config);
320
321    EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID, availability);
322  }
323
324  base::MessageLoop loop_;
325  scoped_ptr<net::ProxyConfigService> proxy_config_service_;
326  scoped_ptr<ProxyConfigServiceImpl> config_service_impl_;
327  TestingPrefServiceSimple pref_service_;
328
329 private:
330  ScopedTestDeviceSettingsService test_device_settings_service_;
331  ScopedTestCrosSettings test_cros_settings_;
332  content::TestBrowserThread ui_thread_;
333  content::TestBrowserThread io_thread_;
334};
335
336TEST_F(ProxyConfigServiceImplTest, NetworkProxy) {
337  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
338    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
339                                    tests[i].description.c_str()));
340
341    base::DictionaryValue test_config;
342    InitConfigWithTestInput(tests[i].input, &test_config);
343    SetConfig(&test_config);
344
345    net::ProxyConfig config;
346    SyncGetLatestProxyConfig(&config);
347
348    EXPECT_EQ(tests[i].auto_detect, config.auto_detect());
349    EXPECT_EQ(tests[i].pac_url, config.pac_url());
350    EXPECT_TRUE(tests[i].proxy_rules.Matches(config.proxy_rules()));
351  }
352}
353
354TEST_F(ProxyConfigServiceImplTest, DynamicPrefsOverride) {
355  // Groupings of 3 test inputs to use for managed, recommended and network
356  // proxies respectively.  Only valid and non-direct test inputs are used.
357  const size_t proxies[][3] = {
358    { 1, 2, 4, },
359    { 1, 4, 2, },
360    { 4, 2, 1, },
361    { 2, 1, 4, },
362    { 2, 4, 5, },
363    { 2, 5, 4, },
364    { 5, 4, 2, },
365    { 4, 2, 5, },
366    { 4, 5, 6, },
367    { 4, 6, 5, },
368    { 6, 5, 4, },
369    { 5, 4, 6, },
370    { 5, 6, 7, },
371    { 5, 7, 6, },
372    { 7, 6, 5, },
373    { 6, 5, 7, },
374    { 6, 7, 8, },
375    { 6, 8, 7, },
376    { 8, 7, 6, },
377    { 7, 6, 8, },
378  };
379  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(proxies); ++i) {
380    const TestParams& managed_params = tests[proxies[i][0]];
381    const TestParams& recommended_params = tests[proxies[i][1]];
382    const TestParams& network_params = tests[proxies[i][2]];
383
384    SCOPED_TRACE(base::StringPrintf(
385        "Test[%" PRIuS "] managed=[%s], recommended=[%s], network=[%s]", i,
386        managed_params.description.c_str(),
387        recommended_params.description.c_str(),
388        network_params.description.c_str()));
389
390    base::DictionaryValue managed_config;
391    InitConfigWithTestInput(managed_params.input, &managed_config);
392    base::DictionaryValue recommended_config;
393    InitConfigWithTestInput(recommended_params.input, &recommended_config);
394    base::DictionaryValue network_config;
395    InitConfigWithTestInput(network_params.input, &network_config);
396
397    // Managed proxy pref should take effect over recommended proxy and
398    // non-existent network proxy.
399    SetConfig(NULL);
400    pref_service_.SetManagedPref(prefs::kProxy, managed_config.DeepCopy());
401    pref_service_.SetRecommendedPref(prefs::kProxy,
402                                     recommended_config.DeepCopy());
403    net::ProxyConfig actual_config;
404    SyncGetLatestProxyConfig(&actual_config);
405    EXPECT_EQ(managed_params.auto_detect, actual_config.auto_detect());
406    EXPECT_EQ(managed_params.pac_url, actual_config.pac_url());
407    EXPECT_TRUE(managed_params.proxy_rules.Matches(
408        actual_config.proxy_rules()));
409
410    // Recommended proxy pref should take effect when managed proxy pref is
411    // removed.
412    pref_service_.RemoveManagedPref(prefs::kProxy);
413    SyncGetLatestProxyConfig(&actual_config);
414    EXPECT_EQ(recommended_params.auto_detect, actual_config.auto_detect());
415    EXPECT_EQ(recommended_params.pac_url, actual_config.pac_url());
416    EXPECT_TRUE(recommended_params.proxy_rules.Matches(
417        actual_config.proxy_rules()));
418
419    // Network proxy should take take effect over recommended proxy pref.
420    SetConfig(&network_config);
421    SyncGetLatestProxyConfig(&actual_config);
422    EXPECT_EQ(network_params.auto_detect, actual_config.auto_detect());
423    EXPECT_EQ(network_params.pac_url, actual_config.pac_url());
424    EXPECT_TRUE(network_params.proxy_rules.Matches(
425        actual_config.proxy_rules()));
426
427    // Managed proxy pref should take effect over network proxy.
428    pref_service_.SetManagedPref(prefs::kProxy, managed_config.DeepCopy());
429    SyncGetLatestProxyConfig(&actual_config);
430    EXPECT_EQ(managed_params.auto_detect, actual_config.auto_detect());
431    EXPECT_EQ(managed_params.pac_url, actual_config.pac_url());
432    EXPECT_TRUE(managed_params.proxy_rules.Matches(
433        actual_config.proxy_rules()));
434
435    // Network proxy should take effect over recommended proxy pref when managed
436    // proxy pref is removed.
437    pref_service_.RemoveManagedPref(prefs::kProxy);
438    SyncGetLatestProxyConfig(&actual_config);
439    EXPECT_EQ(network_params.auto_detect, actual_config.auto_detect());
440    EXPECT_EQ(network_params.pac_url, actual_config.pac_url());
441    EXPECT_TRUE(network_params.proxy_rules.Matches(
442        actual_config.proxy_rules()));
443
444    // Removing recommended proxy pref should have no effect on network proxy.
445    pref_service_.RemoveRecommendedPref(prefs::kProxy);
446    SyncGetLatestProxyConfig(&actual_config);
447    EXPECT_EQ(network_params.auto_detect, actual_config.auto_detect());
448    EXPECT_EQ(network_params.pac_url, actual_config.pac_url());
449    EXPECT_TRUE(network_params.proxy_rules.Matches(
450        actual_config.proxy_rules()));
451  }
452}
453
454}  // namespace chromeos
455