net/proxy/proxy_config_service_linux_unittest.cc - Issue 992733002: Remove //net (except for Android test stuff) and sdch

Side by Side Diff: net/proxy/proxy_config_service_linux_unittest.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
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 "net/proxy/proxy_config_service_linux.h"

6

7 #include <map>

8 #include <string>

9 #include <vector>

10

11 #include "base/bind.h"

12 #include "base/compiler_specific.h"

13 #include "base/files/file_path.h"

14 #include "base/files/file_util.h"

15 #include "base/format_macros.h"

16 #include "base/logging.h"

17 #include "base/strings/string_util.h"

18 #include "base/strings/stringprintf.h"

19 #include "base/synchronization/waitable_event.h"

20 #include "base/threading/thread.h"

21 #include "net/proxy/proxy_config.h"

22 #include "net/proxy/proxy_config_service_common_unittest.h"

23 #include "testing/gtest/include/gtest/gtest.h"

24 #include "testing/platform_test.h"

25

26 namespace net {

27 namespace {

28

29 // Set of values for all environment variables that we might

30 // query. NULL represents an unset variable.

31 struct EnvVarValues {

32 // The strange capitalization is so that the field matches the

33 // environment variable name exactly.

34 const char DESKTOP_SESSION, HOME,

35 KDEHOME, KDE_SESSION_VERSION,

36 auto_proxy, all_proxy,

37 http_proxy, https_proxy, *ftp_proxy,

38 SOCKS_SERVER, SOCKS_VERSION,

39 *no_proxy;

40 };

41

42 // Undo macro pollution from GDK includes (from message_loop.h).

43 #undef TRUE

44 #undef FALSE

45

46 // So as to distinguish between an unset gconf boolean variable and

47 // one that is false.

48 enum BoolSettingValue {

49 UNSET = 0, TRUE, FALSE

50 };

51

52 // Set of values for all gconf settings that we might query.

53 struct GConfValues {

54 // strings

55 const char mode, autoconfig_url,

56 http_host, secure_host, ftp_host, socks_host;

57 // integers

58 int http_port, secure_port, ftp_port, socks_port;

59 // booleans

60 BoolSettingValue use_proxy, same_proxy, use_auth;

61 // string list

62 std::vector<std::string> ignore_hosts;

63 };

64

65 // Mapping from a setting name to the location of the corresponding

66 // value (inside a EnvVarValues or GConfValues struct).

67 template<typename key_type, typename value_type>

68 struct SettingsTable {

69 typedef std::map<key_type, value_type*> map_type;

70

71 // Gets the value from its location

72 value_type Get(key_type key) {

73 typename map_type::const_iterator it = settings.find(key);

74 // In case there's a typo or the unittest becomes out of sync.

75 CHECK(it != settings.end()) << "key " << key << " not found";

76 value_type* value_ptr = it->second;

77 return *value_ptr;

78 }

79

80 map_type settings;

81 };

82

83 class MockEnvironment : public base::Environment {

84 public:

85 MockEnvironment() {

86 #define ENTRY(x) table[#x] = &values.x

87 ENTRY(DESKTOP_SESSION);

88 ENTRY(HOME);

89 ENTRY(KDEHOME);

90 ENTRY(KDE_SESSION_VERSION);

91 ENTRY(auto_proxy);

92 ENTRY(all_proxy);

93 ENTRY(http_proxy);

94 ENTRY(https_proxy);

95 ENTRY(ftp_proxy);

96 ENTRY(no_proxy);

97 ENTRY(SOCKS_SERVER);

98 ENTRY(SOCKS_VERSION);

99 #undef ENTRY

100 Reset();

101 }

102

103 // Zeroes all environment values.

104 void Reset() {

105 EnvVarValues zero_values = { 0 };

106 values = zero_values;

107 }

108

109 // Begin base::Environment implementation.

110 bool GetVar(const char* variable_name, std::string* result) override {

111 std::map<std::string, const char**>::iterator it =

112 table.find(variable_name);

113 if (it != table.end() && *(it->second) != NULL) {

114 // Note that the variable may be defined but empty.

115 result = (it->second);

116 return true;

117 }

118 return false;

119 }

120

121 bool SetVar(const char* variable_name,

122 const std::string& new_value) override {

123 ADD_FAILURE();

124 return false;

125 }

126

127 bool UnSetVar(const char* variable_name) override {

128 ADD_FAILURE();

129 return false;

130 }

131 // End base::Environment implementation.

132

133 // Intentionally public, for convenience when setting up a test.

134 EnvVarValues values;

135

136 private:

137 std::map<std::string, const char**> table;

138 };

139

140 class MockSettingGetter

141 : public ProxyConfigServiceLinux::SettingGetter {

142 public:

143 typedef ProxyConfigServiceLinux::SettingGetter SettingGetter;

144 MockSettingGetter() {

145 #define ENTRY(key, field) \

146 strings_table.settings[SettingGetter::key] = &values.field

147 ENTRY(PROXY_MODE, mode);

148 ENTRY(PROXY_AUTOCONF_URL, autoconfig_url);

149 ENTRY(PROXY_HTTP_HOST, http_host);

150 ENTRY(PROXY_HTTPS_HOST, secure_host);

151 ENTRY(PROXY_FTP_HOST, ftp_host);

152 ENTRY(PROXY_SOCKS_HOST, socks_host);

153 #undef ENTRY

154 #define ENTRY(key, field) \

155 ints_table.settings[SettingGetter::key] = &values.field

156 ENTRY(PROXY_HTTP_PORT, http_port);

157 ENTRY(PROXY_HTTPS_PORT, secure_port);

158 ENTRY(PROXY_FTP_PORT, ftp_port);

159 ENTRY(PROXY_SOCKS_PORT, socks_port);

160 #undef ENTRY

161 #define ENTRY(key, field) \

162 bools_table.settings[SettingGetter::key] = &values.field

163 ENTRY(PROXY_USE_HTTP_PROXY, use_proxy);

164 ENTRY(PROXY_USE_SAME_PROXY, same_proxy);

165 ENTRY(PROXY_USE_AUTHENTICATION, use_auth);

166 #undef ENTRY

167 string_lists_table.settings[SettingGetter::PROXY_IGNORE_HOSTS] =

168 &values.ignore_hosts;

169 Reset();

170 }

171

172 // Zeros all environment values.

173 void Reset() {

174 GConfValues zero_values = { 0 };

175 values = zero_values;

176 }

177

178 bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,

179 const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)

180 override {

181 task_runner_ = glib_task_runner;

182 return true;

183 }

184

185 void ShutDown() override {}

186

187 bool SetUpNotifications(

188 ProxyConfigServiceLinux::Delegate* delegate) override {

189 return true;

190 }

191

192 const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()

193 override {

194 return task_runner_;

195 }

196

197 ProxyConfigSource GetConfigSource() override {

198 return PROXY_CONFIG_SOURCE_TEST;

199 }

200

201 bool GetString(StringSetting key, std::string* result) override {

202 const char* value = strings_table.Get(key);

203 if (value) {

204 *result = value;

205 return true;

206 }

207 return false;

208 }

209

210 bool GetBool(BoolSetting key, bool* result) override {

211 BoolSettingValue value = bools_table.Get(key);

212 switch (value) {

213 case UNSET:

214 return false;

215 case TRUE:

216 *result = true;

217 break;

218 case FALSE:

219 *result = false;

220 }

221 return true;

222 }

223

224 bool GetInt(IntSetting key, int* result) override {

225 // We don't bother to distinguish unset keys from 0 values.

226 *result = ints_table.Get(key);

227 return true;

228 }

229

230 bool GetStringList(StringListSetting key,

231 std::vector<std::string>* result) override {

232 *result = string_lists_table.Get(key);

233 // We don't bother to distinguish unset keys from empty lists.

234 return !result->empty();

235 }

236

237 bool BypassListIsReversed() override { return false; }

238

239 bool MatchHostsUsingSuffixMatching() override { return false; }

240

241 // Intentionally public, for convenience when setting up a test.

242 GConfValues values;

243

244 private:

245 scoped_refptr<base::SingleThreadTaskRunner> task_runner_;

246 SettingsTable<StringSetting, const char*> strings_table;

247 SettingsTable<BoolSetting, BoolSettingValue> bools_table;

248 SettingsTable<IntSetting, int> ints_table;

249 SettingsTable<StringListSetting,

250 std::vector<std::string> > string_lists_table;

251 };

252

253 } // namespace

254 } // namespace net

255

256 // This helper class runs ProxyConfigServiceLinux::GetLatestProxyConfig() on

257 // the IO thread and synchronously waits for the result.

258 // Some code duplicated from proxy_script_fetcher_unittest.cc.

259 class SynchConfigGetter {

260 public:

261 // Takes ownership of \|config_service\|.

262 explicit SynchConfigGetter(net::ProxyConfigServiceLinux* config_service)

263 : event_(false, false),

264 io_thread_("IO_Thread"),

265 config_service_(config_service) {

266 // Start an IO thread.

267 base::Thread::Options options;

268 options.message_loop_type = base::MessageLoop::TYPE_IO;

269 io_thread_.StartWithOptions(options);

270

271 // Make sure the thread started.

272 io_thread_.message_loop()->PostTask(FROM_HERE,

273 base::Bind(&SynchConfigGetter::Init, base::Unretained(this)));

274 Wait();

275 }

276

277 ~SynchConfigGetter() {

278 // Let the config service post a destroy message to the IO thread

279 // before cleaning up that thread.

280 delete config_service_;

281 // Clean up the IO thread.

282 io_thread_.message_loop()->PostTask(FROM_HERE,

283 base::Bind(&SynchConfigGetter::CleanUp, base::Unretained(this)));

284 Wait();

285 }

286

287 // Does gconf setup and initial fetch of the proxy config,

288 // all on the calling thread (meant to be the thread with the

289 // default glib main loop, which is the UI thread).

290 void SetupAndInitialFetch() {

291 // We pass the mock IO thread as both the IO and file threads.

292 config_service_->SetupAndFetchInitialConfig(

293 base::MessageLoopProxy::current(),

294 io_thread_.message_loop_proxy(),

295 io_thread_.message_loop_proxy());

296 }

297 // Synchronously gets the proxy config.

298 net::ProxyConfigService::ConfigAvailability SyncGetLatestProxyConfig(

299 net::ProxyConfig* config) {

300 io_thread_.message_loop()->PostTask(FROM_HERE,

301 base::Bind(&SynchConfigGetter::GetLatestConfigOnIOThread,

302 base::Unretained(this)));

303 Wait();

304 *config = proxy_config_;

305 return get_latest_config_result_;

306 }

307

308 private:

309 // [Runs on \|io_thread_\|]

310 void Init() {

311 event_.Signal();

312 }

313

314 // Calls GetLatestProxyConfig, running on \|io_thread_\| Signals \|event_\|

315 // on completion.

316 void GetLatestConfigOnIOThread() {

317 get_latest_config_result_ =

318 config_service_->GetLatestProxyConfig(&proxy_config_);

319 event_.Signal();

320 }

321

322 // [Runs on \|io_thread_\|] Signals \|event_\| on cleanup completion.

323 void CleanUp() {

324 base::MessageLoop::current()->RunUntilIdle();

325 event_.Signal();

326 }

327

328 void Wait() {

329 event_.Wait();

330 event_.Reset();

331 }

332

333 base::WaitableEvent event_;

334 base::Thread io_thread_;

335

336 net::ProxyConfigServiceLinux* config_service_;

337

338 // The config obtained by \|io_thread_\| and read back by the main

339 // thread.

340 net::ProxyConfig proxy_config_;

341

342 // Return value from GetLatestProxyConfig().

343 net::ProxyConfigService::ConfigAvailability get_latest_config_result_;

344 };

345

346 namespace net {

347

348 // This test fixture is only really needed for the KDEConfigParser test case,

349 // but all the test cases with the same prefix ("ProxyConfigServiceLinuxTest")

350 // must use the same test fixture class (also "ProxyConfigServiceLinuxTest").

351 class ProxyConfigServiceLinuxTest : public PlatformTest {

352 protected:

353 void SetUp() override {

354 PlatformTest::SetUp();

355 // Set up a temporary KDE home directory.

356 std::string prefix("ProxyConfigServiceLinuxTest_user_home");

357 base::CreateNewTempDirectory(prefix, &user_home_);

358 kde_home_ = user_home_.Append(FILE_PATH_LITERAL(".kde"));

359 base::FilePath path = kde_home_.Append(FILE_PATH_LITERAL("share"));

360 path = path.Append(FILE_PATH_LITERAL("config"));

361 base::CreateDirectory(path);

362 kioslaverc_ = path.Append(FILE_PATH_LITERAL("kioslaverc"));

363 // Set up paths but do not create the directory for .kde4.

364 kde4_home_ = user_home_.Append(FILE_PATH_LITERAL(".kde4"));

365 path = kde4_home_.Append(FILE_PATH_LITERAL("share"));

366 kde4_config_ = path.Append(FILE_PATH_LITERAL("config"));

367 kioslaverc4_ = kde4_config_.Append(FILE_PATH_LITERAL("kioslaverc"));

368 }

369

370 void TearDown() override {

371 // Delete the temporary KDE home directory.

372 base::DeleteFile(user_home_, true);

373 PlatformTest::TearDown();

374 }

375

376 base::FilePath user_home_;

377 // KDE3 paths.

378 base::FilePath kde_home_;

379 base::FilePath kioslaverc_;

380 // KDE4 paths.

381 base::FilePath kde4_home_;

382 base::FilePath kde4_config_;

383 base::FilePath kioslaverc4_;

384 };

385

386 // Builds an identifier for each test in an array.

387 #define TEST_DESC(desc) base::StringPrintf("at line %d <%s>", __LINE__, desc)

388

389 TEST_F(ProxyConfigServiceLinuxTest, BasicGConfTest) {

390 std::vector<std::string> empty_ignores;

391

392 std::vector<std::string> google_ignores;

393 google_ignores.push_back("*.google.com");

394

395 // Inspired from proxy_config_service_win_unittest.cc.

396 // Very neat, but harder to track down failures though.

397 const struct {

398 // Short description to identify the test

399 std::string description;

400

401 // Input.

402 GConfValues values;

403

404 // Expected outputs (availability and fields of ProxyConfig).

405 ProxyConfigService::ConfigAvailability availability;

406 bool auto_detect;

407 GURL pac_url;

408 ProxyRulesExpectation proxy_rules;

409 } tests[] = {

410 {

411 TEST_DESC("No proxying"),

412 { // Input.

413 "none", // mode

414 "", // autoconfig_url

415 "", "", "", "", // hosts

416 0, 0, 0, 0, // ports

417 FALSE, FALSE, FALSE, // use, same, auth

418 empty_ignores, // ignore_hosts

419 },

420

421 // Expected result.

422 ProxyConfigService::CONFIG_VALID,

423 false, // auto_detect

424 GURL(), // pac_url

425 ProxyRulesExpectation::Empty(),

426 },

427

428 {

429 TEST_DESC("Auto detect"),

430 { // Input.

431 "auto", // mode

432 "", // autoconfig_url

433 "", "", "", "", // hosts

434 0, 0, 0, 0, // ports

435 FALSE, FALSE, FALSE, // use, same, auth

436 empty_ignores, // ignore_hosts

437 },

438

439 // Expected result.

440 ProxyConfigService::CONFIG_VALID,

441 true, // auto_detect

442 GURL(), // pac_url

443 ProxyRulesExpectation::Empty(),

444 },

445

446 {

447 TEST_DESC("Valid PAC URL"),

448 { // Input.

449 "auto", // mode

450 "http://wpad/wpad.dat", // autoconfig_url

451 "", "", "", "", // hosts

452 0, 0, 0, 0, // ports

453 FALSE, FALSE, FALSE, // use, same, auth

454 empty_ignores, // ignore_hosts

455 },

456

457 // Expected result.

458 ProxyConfigService::CONFIG_VALID,

459 false, // auto_detect

460 GURL("http://wpad/wpad.dat"), // pac_url

461 ProxyRulesExpectation::Empty(),

462 },

463

464 {

465 TEST_DESC("Invalid PAC URL"),

466 { // Input.

467 "auto", // mode

468 "wpad.dat", // autoconfig_url

469 "", "", "", "", // hosts

470 0, 0, 0, 0, // ports

471 FALSE, FALSE, FALSE, // use, same, auth

472 empty_ignores, // ignore_hosts

473 },

474

475 // Expected result.

476 ProxyConfigService::CONFIG_VALID,

477 false, // auto_detect

478 GURL(), // pac_url

479 ProxyRulesExpectation::Empty(),

480 },

481

482 {

483 TEST_DESC("Single-host in proxy list"),

484 { // Input.

485 "manual", // mode

486 "", // autoconfig_url

487 "www.google.com", "", "", "", // hosts

488 80, 0, 0, 0, // ports

489 TRUE, TRUE, FALSE, // use, same, auth

490 empty_ignores, // ignore_hosts

491 },

492

493 // Expected result.

494 ProxyConfigService::CONFIG_VALID,

495 false, // auto_detect

496 GURL(), // pac_url

497 ProxyRulesExpectation::Single(

498 "www.google.com:80", // single proxy

499 ""), // bypass rules

500 },

501

502 {

503 TEST_DESC("use_http_proxy is honored"),

504 { // Input.

505 "manual", // mode

506 "", // autoconfig_url

507 "www.google.com", "", "", "", // hosts

508 80, 0, 0, 0, // ports

509 FALSE, TRUE, FALSE, // use, same, auth

510 empty_ignores, // ignore_hosts

511 },

512

513 // Expected result.

514 ProxyConfigService::CONFIG_VALID,

515 false, // auto_detect

516 GURL(), // pac_url

517 ProxyRulesExpectation::Empty(),

518 },

519

520 {

521 TEST_DESC("use_http_proxy and use_same_proxy are optional"),

522 { // Input.

523 "manual", // mode

524 "", // autoconfig_url

525 "www.google.com", "", "", "", // hosts

526 80, 0, 0, 0, // ports

527 UNSET, UNSET, FALSE, // use, same, auth

528 empty_ignores, // ignore_hosts

529 },

530

531 // Expected result.

532 ProxyConfigService::CONFIG_VALID,

533 false, // auto_detect

534 GURL(), // pac_url

535 ProxyRulesExpectation::PerScheme(

536 "www.google.com:80", // http

537 "", // https

538 "", // ftp

539 ""), // bypass rules

540 },

541

542 {

543 TEST_DESC("Single-host, different port"),

544 { // Input.

545 "manual", // mode

546 "", // autoconfig_url

547 "www.google.com", "", "", "", // hosts

548 88, 0, 0, 0, // ports

549 TRUE, TRUE, FALSE, // use, same, auth

550 empty_ignores, // ignore_hosts

551 },

552

553 // Expected result.

554 ProxyConfigService::CONFIG_VALID,

555 false, // auto_detect

556 GURL(), // pac_url

557 ProxyRulesExpectation::Single(

558 "www.google.com:88", // single proxy

559 ""), // bypass rules

560 },

561

562 {

563 TEST_DESC("Per-scheme proxy rules"),

564 { // Input.

565 "manual", // mode

566 "", // autoconfig_url

567 "www.google.com", // http_host

568 "www.foo.com", // secure_host

569 "ftp.foo.com", // ftp

570 "", // socks

571 88, 110, 121, 0, // ports

572 TRUE, FALSE, FALSE, // use, same, auth

573 empty_ignores, // ignore_hosts

574 },

575

576 // Expected result.

577 ProxyConfigService::CONFIG_VALID,

578 false, // auto_detect

579 GURL(), // pac_url

580 ProxyRulesExpectation::PerScheme(

581 "www.google.com:88", // http

582 "www.foo.com:110", // https

583 "ftp.foo.com:121", // ftp

584 ""), // bypass rules

585 },

586

587 {

588 TEST_DESC("socks"),

589 { // Input.

590 "manual", // mode

591 "", // autoconfig_url

592 "", "", "", "socks.com", // hosts

593 0, 0, 0, 99, // ports

594 TRUE, FALSE, FALSE, // use, same, auth

595 empty_ignores, // ignore_hosts

596 },

597

598 // Expected result.

599 ProxyConfigService::CONFIG_VALID,

600 false, // auto_detect

601 GURL(), // pac_url

602 ProxyRulesExpectation::Single(

603 "socks5://socks.com:99", // single proxy

604 "") // bypass rules

605 },

606

607 {

608 TEST_DESC("Per-scheme proxy rules with fallback to SOCKS"),

609 { // Input.

610 "manual", // mode

611 "", // autoconfig_url

612 "www.google.com", // http_host

613 "www.foo.com", // secure_host

614 "ftp.foo.com", // ftp

615 "foobar.net", // socks

616 88, 110, 121, 99, // ports

617 TRUE, FALSE, FALSE, // use, same, auth

618 empty_ignores, // ignore_hosts

619 },

620

621 // Expected result.

622 ProxyConfigService::CONFIG_VALID,

623 false, // auto_detect

624 GURL(), // pac_url

625 ProxyRulesExpectation::PerSchemeWithSocks(

626 "www.google.com:88", // http

627 "www.foo.com:110", // https

628 "ftp.foo.com:121", // ftp

629 "socks5://foobar.net:99", // socks

630 ""), // bypass rules

631 },

632

633 {

634 TEST_DESC("Per-scheme proxy rules (just HTTP) with fallback to SOCKS"),

635 { // Input.

636 "manual", // mode

637 "", // autoconfig_url

638 "www.google.com", // http_host

639 "", // secure_host

640 "", // ftp

641 "foobar.net", // socks

642 88, 0, 0, 99, // ports

643 TRUE, FALSE, FALSE, // use, same, auth

644 empty_ignores, // ignore_hosts

645 },

646

647 // Expected result.

648 ProxyConfigService::CONFIG_VALID,

649 false, // auto_detect

650 GURL(), // pac_url

651 ProxyRulesExpectation::PerSchemeWithSocks(

652 "www.google.com:88", // http

653 "", // https

654 "", // ftp

655 "socks5://foobar.net:99", // socks

656 ""), // bypass rules

657 },

658

659 {

660 TEST_DESC("Bypass *.google.com"),

661 { // Input.

662 "manual", // mode

663 "", // autoconfig_url

664 "www.google.com", "", "", "", // hosts

665 80, 0, 0, 0, // ports

666 TRUE, TRUE, FALSE, // use, same, auth

667 google_ignores, // ignore_hosts

668 },

669

670 ProxyConfigService::CONFIG_VALID,

671 false, // auto_detect

672 GURL(), // pac_url

673 ProxyRulesExpectation::Single(

674 "www.google.com:80", // single proxy

675 "*.google.com"), // bypass rules

676 },

677 };

678

679 for (size_t i = 0; i < arraysize(tests); ++i) {

680 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,

681 tests[i].description.c_str()));

682 MockEnvironment* env = new MockEnvironment;

683 MockSettingGetter* setting_getter = new MockSettingGetter;

684 SynchConfigGetter sync_config_getter(

685 new ProxyConfigServiceLinux(env, setting_getter));

686 ProxyConfig config;

687 setting_getter->values = tests[i].values;

688 sync_config_getter.SetupAndInitialFetch();

689 ProxyConfigService::ConfigAvailability availability =

690 sync_config_getter.SyncGetLatestProxyConfig(&config);

691 EXPECT_EQ(tests[i].availability, availability);

692

693 if (availability == ProxyConfigService::CONFIG_VALID) {

694 EXPECT_EQ(tests[i].auto_detect, config.auto_detect());

695 EXPECT_EQ(tests[i].pac_url, config.pac_url());

696 EXPECT_TRUE(tests[i].proxy_rules.Matches(config.proxy_rules()));

697 }

698 }

699 }

700

701 TEST_F(ProxyConfigServiceLinuxTest, BasicEnvTest) {

702 // Inspired from proxy_config_service_win_unittest.cc.

703 const struct {

704 // Short description to identify the test

705 std::string description;

706

707 // Input.

708 EnvVarValues values;

709

710 // Expected outputs (availability and fields of ProxyConfig).

711 ProxyConfigService::ConfigAvailability availability;

712 bool auto_detect;

713 GURL pac_url;

714 ProxyRulesExpectation proxy_rules;

715 } tests[] = {

716 {

717 TEST_DESC("No proxying"),

718 { // Input.

719 NULL, // DESKTOP_SESSION

720 NULL, // HOME

721 NULL, // KDEHOME

722 NULL, // KDE_SESSION_VERSION

723 NULL, // auto_proxy

724 NULL, // all_proxy

725 NULL, NULL, NULL, // per-proto proxies

726 NULL, NULL, // SOCKS

727 "*", // no_proxy

728 },

729

730 // Expected result.

731 ProxyConfigService::CONFIG_VALID,

732 false, // auto_detect

733 GURL(), // pac_url

734 ProxyRulesExpectation::Empty(),

735 },

736

737 {

738 TEST_DESC("Auto detect"),

739 { // Input.

740 NULL, // DESKTOP_SESSION

741 NULL, // HOME

742 NULL, // KDEHOME

743 NULL, // KDE_SESSION_VERSION

744 "", // auto_proxy

745 NULL, // all_proxy

746 NULL, NULL, NULL, // per-proto proxies

747 NULL, NULL, // SOCKS

748 NULL, // no_proxy

749 },

750

751 // Expected result.

752 ProxyConfigService::CONFIG_VALID,

753 true, // auto_detect

754 GURL(), // pac_url

755 ProxyRulesExpectation::Empty(),

756 },

757

758 {

759 TEST_DESC("Valid PAC URL"),

760 { // Input.

761 NULL, // DESKTOP_SESSION

762 NULL, // HOME

763 NULL, // KDEHOME

764 NULL, // KDE_SESSION_VERSION

765 "http://wpad/wpad.dat", // auto_proxy

766 NULL, // all_proxy

767 NULL, NULL, NULL, // per-proto proxies

768 NULL, NULL, // SOCKS

769 NULL, // no_proxy

770 },

771

772 // Expected result.

773 ProxyConfigService::CONFIG_VALID,

774 false, // auto_detect

775 GURL("http://wpad/wpad.dat"), // pac_url

776 ProxyRulesExpectation::Empty(),

777 },

778

779 {

780 TEST_DESC("Invalid PAC URL"),

781 { // Input.

782 NULL, // DESKTOP_SESSION

783 NULL, // HOME

784 NULL, // KDEHOME

785 NULL, // KDE_SESSION_VERSION

786 "wpad.dat", // auto_proxy

787 NULL, // all_proxy

788 NULL, NULL, NULL, // per-proto proxies

789 NULL, NULL, // SOCKS

790 NULL, // no_proxy

791 },

792

793 // Expected result.

794 ProxyConfigService::CONFIG_VALID,

795 false, // auto_detect

796 GURL(), // pac_url

797 ProxyRulesExpectation::Empty(),

798 },

799

800 {

801 TEST_DESC("Single-host in proxy list"),

802 { // Input.

803 NULL, // DESKTOP_SESSION

804 NULL, // HOME

805 NULL, // KDEHOME

806 NULL, // KDE_SESSION_VERSION

807 NULL, // auto_proxy

808 "www.google.com", // all_proxy

809 NULL, NULL, NULL, // per-proto proxies

810 NULL, NULL, // SOCKS

811 NULL, // no_proxy

812 },

813

814 // Expected result.

815 ProxyConfigService::CONFIG_VALID,

816 false, // auto_detect

817 GURL(), // pac_url

818 ProxyRulesExpectation::Single(

819 "www.google.com:80", // single proxy

820 ""), // bypass rules

821 },

822

823 {

824 TEST_DESC("Single-host, different port"),

825 { // Input.

826 NULL, // DESKTOP_SESSION

827 NULL, // HOME

828 NULL, // KDEHOME

829 NULL, // KDE_SESSION_VERSION

830 NULL, // auto_proxy

831 "www.google.com:99", // all_proxy

832 NULL, NULL, NULL, // per-proto proxies

833 NULL, NULL, // SOCKS

834 NULL, // no_proxy

835 },

836

837 // Expected result.

838 ProxyConfigService::CONFIG_VALID,

839 false, // auto_detect

840 GURL(), // pac_url

841 ProxyRulesExpectation::Single(

842 "www.google.com:99", // single

843 ""), // bypass rules

844 },

845

846 {

847 TEST_DESC("Tolerate a scheme"),

848 { // Input.

849 NULL, // DESKTOP_SESSION

850 NULL, // HOME

851 NULL, // KDEHOME

852 NULL, // KDE_SESSION_VERSION

853 NULL, // auto_proxy

854 "http://www.google.com:99", // all_proxy

855 NULL, NULL, NULL, // per-proto proxies

856 NULL, NULL, // SOCKS

857 NULL, // no_proxy

858 },

859

860 // Expected result.

861 ProxyConfigService::CONFIG_VALID,

862 false, // auto_detect

863 GURL(), // pac_url

864 ProxyRulesExpectation::Single(

865 "www.google.com:99", // single proxy

866 ""), // bypass rules

867 },

868

869 {

870 TEST_DESC("Per-scheme proxy rules"),

871 { // Input.

872 NULL, // DESKTOP_SESSION

873 NULL, // HOME

874 NULL, // KDEHOME

875 NULL, // KDE_SESSION_VERSION

876 NULL, // auto_proxy

877 NULL, // all_proxy

878 "www.google.com:80", "www.foo.com:110", "ftp.foo.com:121", // per-proto

879 NULL, NULL, // SOCKS

880 NULL, // no_proxy

881 },

882

883 // Expected result.

884 ProxyConfigService::CONFIG_VALID,

885 false, // auto_detect

886 GURL(), // pac_url

887 ProxyRulesExpectation::PerScheme(

888 "www.google.com:80", // http

889 "www.foo.com:110", // https

890 "ftp.foo.com:121", // ftp

891 ""), // bypass rules

892 },

893

894 {

895 TEST_DESC("socks"),

896 { // Input.

897 NULL, // DESKTOP_SESSION

898 NULL, // HOME

899 NULL, // KDEHOME

900 NULL, // KDE_SESSION_VERSION

901 NULL, // auto_proxy

902 "", // all_proxy

903 NULL, NULL, NULL, // per-proto proxies

904 "socks.com:888", NULL, // SOCKS

905 NULL, // no_proxy

906 },

907

908 // Expected result.

909 ProxyConfigService::CONFIG_VALID,

910 false, // auto_detect

911 GURL(), // pac_url

912 ProxyRulesExpectation::Single(

913 "socks5://socks.com:888", // single proxy

914 ""), // bypass rules

915 },

916

917 {

918 TEST_DESC("socks4"),

919 { // Input.

920 NULL, // DESKTOP_SESSION

921 NULL, // HOME

922 NULL, // KDEHOME

923 NULL, // KDE_SESSION_VERSION

924 NULL, // auto_proxy

925 "", // all_proxy

926 NULL, NULL, NULL, // per-proto proxies

927 "socks.com:888", "4", // SOCKS

928 NULL, // no_proxy

929 },

930

931 // Expected result.

932 ProxyConfigService::CONFIG_VALID,

933 false, // auto_detect

934 GURL(), // pac_url

935 ProxyRulesExpectation::Single(

936 "socks4://socks.com:888", // single proxy

937 ""), // bypass rules

938 },

939

940 {

941 TEST_DESC("socks default port"),

942 { // Input.

943 NULL, // DESKTOP_SESSION

944 NULL, // HOME

945 NULL, // KDEHOME

946 NULL, // KDE_SESSION_VERSION

947 NULL, // auto_proxy

948 "", // all_proxy

949 NULL, NULL, NULL, // per-proto proxies

950 "socks.com", NULL, // SOCKS

951 NULL, // no_proxy

952 },

953

954 // Expected result.

955 ProxyConfigService::CONFIG_VALID,

956 false, // auto_detect

957 GURL(), // pac_url

958 ProxyRulesExpectation::Single(

959 "socks5://socks.com:1080", // single proxy

960 ""), // bypass rules

961 },

962

963 {

964 TEST_DESC("bypass"),

965 { // Input.

966 NULL, // DESKTOP_SESSION

967 NULL, // HOME

968 NULL, // KDEHOME

969 NULL, // KDE_SESSION_VERSION

970 NULL, // auto_proxy

971 "www.google.com", // all_proxy

972 NULL, NULL, NULL, // per-proto

973 NULL, NULL, // SOCKS

974 ".google.com, foo.com:99, 1.2.3.4:22, 127.0.0.1/8", // no_proxy

975 },

976

977 // Expected result.

978 ProxyConfigService::CONFIG_VALID,

979 false, // auto_detect

980 GURL(), // pac_url

981 ProxyRulesExpectation::Single(

982 "www.google.com:80",

983 ".google.com,foo.com:99,1.2.3.4:22,127.0.0.1/8"),

984 },

985 };

986

987 for (size_t i = 0; i < arraysize(tests); ++i) {

988 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,

989 tests[i].description.c_str()));

990 MockEnvironment* env = new MockEnvironment;

991 MockSettingGetter* setting_getter = new MockSettingGetter;

992 SynchConfigGetter sync_config_getter(

993 new ProxyConfigServiceLinux(env, setting_getter));

994 ProxyConfig config;

995 env->values = tests[i].values;

996 sync_config_getter.SetupAndInitialFetch();

997 ProxyConfigService::ConfigAvailability availability =

998 sync_config_getter.SyncGetLatestProxyConfig(&config);

999 EXPECT_EQ(tests[i].availability, availability);

1000

1001 if (availability == ProxyConfigService::CONFIG_VALID) {

1002 EXPECT_EQ(tests[i].auto_detect, config.auto_detect());

1003 EXPECT_EQ(tests[i].pac_url, config.pac_url());

1004 EXPECT_TRUE(tests[i].proxy_rules.Matches(config.proxy_rules()));

1005 }

1006 }

1007 }

1008

1009 TEST_F(ProxyConfigServiceLinuxTest, GconfNotification) {

1010 MockEnvironment* env = new MockEnvironment;

1011 MockSettingGetter* setting_getter = new MockSettingGetter;

1012 ProxyConfigServiceLinux* service =

1013 new ProxyConfigServiceLinux(env, setting_getter);

1014 SynchConfigGetter sync_config_getter(service);

1015 ProxyConfig config;

1016

1017 // Start with no proxy.

1018 setting_getter->values.mode = "none";

1019 sync_config_getter.SetupAndInitialFetch();

1020 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1021 sync_config_getter.SyncGetLatestProxyConfig(&config));

1022 EXPECT_FALSE(config.auto_detect());

1023

1024 // Now set to auto-detect.

1025 setting_getter->values.mode = "auto";

1026 // Simulate setting change notification callback.

1027 service->OnCheckProxyConfigSettings();

1028 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1029 sync_config_getter.SyncGetLatestProxyConfig(&config));

1030 EXPECT_TRUE(config.auto_detect());

1031 }

1032

1033 TEST_F(ProxyConfigServiceLinuxTest, KDEConfigParser) {

1034 // One of the tests below needs a worst-case long line prefix. We build it

1035 // programmatically so that it will always be the right size.

1036 std::string long_line;

1037 size_t limit = ProxyConfigServiceLinux::SettingGetter::BUFFER_SIZE - 1;

1038 for (size_t i = 0; i < limit; ++i)

1039 long_line += "-";

1040

1041 // Inspired from proxy_config_service_win_unittest.cc.

1042 const struct {

1043 // Short description to identify the test

1044 std::string description;

1045

1046 // Input.

1047 std::string kioslaverc;

1048 EnvVarValues env_values;

1049

1050 // Expected outputs (availability and fields of ProxyConfig).

1051 ProxyConfigService::ConfigAvailability availability;

1052 bool auto_detect;

1053 GURL pac_url;

1054 ProxyRulesExpectation proxy_rules;

1055 } tests[] = {

1056 {

1057 TEST_DESC("No proxying"),

1058

1059 // Input.

1060 "[Proxy Settings]\nProxyType=0\n",

1061 {}, // env_values

1062

1063 // Expected result.

1064 ProxyConfigService::CONFIG_VALID,

1065 false, // auto_detect

1066 GURL(), // pac_url

1067 ProxyRulesExpectation::Empty(),

1068 },

1069

1070 {

1071 TEST_DESC("Auto detect"),

1072

1073 // Input.

1074 "[Proxy Settings]\nProxyType=3\n",

1075 {}, // env_values

1076

1077 // Expected result.

1078 ProxyConfigService::CONFIG_VALID,

1079 true, // auto_detect

1080 GURL(), // pac_url

1081 ProxyRulesExpectation::Empty(),

1082 },

1083

1084 {

1085 TEST_DESC("Valid PAC URL"),

1086

1087 // Input.

1088 "[Proxy Settings]\nProxyType=2\n"

1089 "Proxy Config Script=http://wpad/wpad.dat\n",

1090 {}, // env_values

1091

1092 // Expected result.

1093 ProxyConfigService::CONFIG_VALID,

1094 false, // auto_detect

1095 GURL("http://wpad/wpad.dat"), // pac_url

1096 ProxyRulesExpectation::Empty(),

1097 },

1098

1099 {

1100 TEST_DESC("Valid PAC file without file://"),

1101

1102 // Input.

1103 "[Proxy Settings]\nProxyType=2\n"

1104 "Proxy Config Script=/wpad/wpad.dat\n",

1105 {}, // env_values

1106

1107 // Expected result.

1108 ProxyConfigService::CONFIG_VALID,

1109 false, // auto_detect

1110 GURL("file:///wpad/wpad.dat"), // pac_url

1111 ProxyRulesExpectation::Empty(),

1112 },

1113

1114 {

1115 TEST_DESC("Per-scheme proxy rules"),

1116

1117 // Input.

1118 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1119 "httpsProxy=www.foo.com\nftpProxy=ftp.foo.com\n",

1120 {}, // env_values

1121

1122 // Expected result.

1123 ProxyConfigService::CONFIG_VALID,

1124 false, // auto_detect

1125 GURL(), // pac_url

1126 ProxyRulesExpectation::PerScheme(

1127 "www.google.com:80", // http

1128 "www.foo.com:80", // https

1129 "ftp.foo.com:80", // http

1130 ""), // bypass rules

1131 },

1132

1133 {

1134 TEST_DESC("Only HTTP proxy specified"),

1135

1136 // Input.

1137 "[Proxy Settings]\nProxyType=1\n"

1138 "httpProxy=www.google.com\n",

1139 {}, // env_values

1140

1141 // Expected result.

1142 ProxyConfigService::CONFIG_VALID,

1143 false, // auto_detect

1144 GURL(), // pac_url

1145 ProxyRulesExpectation::PerScheme(

1146 "www.google.com:80", // http

1147 "", // https

1148 "", // ftp

1149 ""), // bypass rules

1150 },

1151

1152 {

1153 TEST_DESC("Only HTTP proxy specified, different port"),

1154

1155 // Input.

1156 "[Proxy Settings]\nProxyType=1\n"

1157 "httpProxy=www.google.com:88\n",

1158 {}, // env_values

1159

1160 // Expected result.

1161 ProxyConfigService::CONFIG_VALID,

1162 false, // auto_detect

1163 GURL(), // pac_url

1164 ProxyRulesExpectation::PerScheme(

1165 "www.google.com:88", // http

1166 "", // https

1167 "", // ftp

1168 ""), // bypass rules

1169 },

1170

1171 {

1172 TEST_DESC("Only HTTP proxy specified, different port, space-delimited"),

1173

1174 // Input.

1175 "[Proxy Settings]\nProxyType=1\n"

1176 "httpProxy=www.google.com 88\n",

1177 {}, // env_values

1178

1179 // Expected result.

1180 ProxyConfigService::CONFIG_VALID,

1181 false, // auto_detect

1182 GURL(), // pac_url

1183 ProxyRulesExpectation::PerScheme(

1184 "www.google.com:88", // http

1185 "", // https

1186 "", // ftp

1187 ""), // bypass rules

1188 },

1189

1190 {

1191 TEST_DESC("Bypass *.google.com"),

1192

1193 // Input.

1194 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1195 "NoProxyFor=.google.com\n",

1196 {}, // env_values

1197

1198 // Expected result.

1199 ProxyConfigService::CONFIG_VALID,

1200 false, // auto_detect

1201 GURL(), // pac_url

1202 ProxyRulesExpectation::PerScheme(

1203 "www.google.com:80", // http

1204 "", // https

1205 "", // ftp

1206 "*.google.com"), // bypass rules

1207 },

1208

1209 {

1210 TEST_DESC("Bypass .google.com and .kde.org"),

1211

1212 // Input.

1213 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1214 "NoProxyFor=.google.com,.kde.org\n",

1215 {}, // env_values

1216

1217 // Expected result.

1218 ProxyConfigService::CONFIG_VALID,

1219 false, // auto_detect

1220 GURL(), // pac_url

1221 ProxyRulesExpectation::PerScheme(

1222 "www.google.com:80", // http

1223 "", // https

1224 "", // ftp

1225 ".google.com,.kde.org"), // bypass rules

1226 },

1227

1228 {

1229 TEST_DESC("Correctly parse bypass list with ReversedException"),

1230

1231 // Input.

1232 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1233 "NoProxyFor=.google.com\nReversedException=true\n",

1234 {}, // env_values

1235

1236 // Expected result.

1237 ProxyConfigService::CONFIG_VALID,

1238 false, // auto_detect

1239 GURL(), // pac_url

1240 ProxyRulesExpectation::PerSchemeWithBypassReversed(

1241 "www.google.com:80", // http

1242 "", // https

1243 "", // ftp

1244 "*.google.com"), // bypass rules

1245 },

1246

1247 {

1248 TEST_DESC("socks"),

1249

1250 // Input.

1251 "[Proxy Settings]\nProxyType=1\nsocksProxy=socks.com 888\n",

1252 {}, // env_values

1253

1254 // Expected result.

1255 ProxyConfigService::CONFIG_VALID,

1256 false, // auto_detect

1257 GURL(), // pac_url

1258 ProxyRulesExpectation::Single(

1259 "socks5://socks.com:888", // single proxy

1260 ""), // bypass rules

1261 },

1262

1263 {

1264 TEST_DESC("socks4"),

1265

1266 // Input.

1267 "[Proxy Settings]\nProxyType=1\nsocksProxy=socks4://socks.com 888\n",

1268 {}, // env_values

1269

1270 // Expected result.

1271 ProxyConfigService::CONFIG_VALID,

1272 false, // auto_detect

1273 GURL(), // pac_url

1274 ProxyRulesExpectation::Single(

1275 "socks4://socks.com:888", // single proxy

1276 ""), // bypass rules

1277 },

1278

1279 {

1280 TEST_DESC("Treat all hostname patterns as wildcard patterns"),

1281

1282 // Input.

1283 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1284 "NoProxyFor=google.com,kde.org,<local>\n",

1285 {}, // env_values

1286

1287 // Expected result.

1288 ProxyConfigService::CONFIG_VALID,

1289 false, // auto_detect

1290 GURL(), // pac_url

1291 ProxyRulesExpectation::PerScheme(

1292 "www.google.com:80", // http

1293 "", // https

1294 "", // ftp

1295 "google.com,kde.org,<local>"), // bypass rules

1296 },

1297

1298 {

1299 TEST_DESC("Allow trailing whitespace after boolean value"),

1300

1301 // Input.

1302 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1303 "NoProxyFor=.google.com\nReversedException=true \n",

1304 {}, // env_values

1305

1306 // Expected result.

1307 ProxyConfigService::CONFIG_VALID,

1308 false, // auto_detect

1309 GURL(), // pac_url

1310 ProxyRulesExpectation::PerSchemeWithBypassReversed(

1311 "www.google.com:80", // http

1312 "", // https

1313 "", // ftp

1314 "*.google.com"), // bypass rules

1315 },

1316

1317 {

1318 TEST_DESC("Ignore settings outside [Proxy Settings]"),

1319

1320 // Input.

1321 "httpsProxy=www.foo.com\n[Proxy Settings]\nProxyType=1\n"

1322 "httpProxy=www.google.com\n[Other Section]\nftpProxy=ftp.foo.com\n",

1323 {}, // env_values

1324

1325 // Expected result.

1326 ProxyConfigService::CONFIG_VALID,

1327 false, // auto_detect

1328 GURL(), // pac_url

1329 ProxyRulesExpectation::PerScheme(

1330 "www.google.com:80", // http

1331 "", // https

1332 "", // ftp

1333 ""), // bypass rules

1334 },

1335

1336 {

1337 TEST_DESC("Handle CRLF line endings"),

1338

1339 // Input.

1340 "[Proxy Settings]\r\nProxyType=1\r\nhttpProxy=www.google.com\r\n",

1341 {}, // env_values

1342

1343 // Expected result.

1344 ProxyConfigService::CONFIG_VALID,

1345 false, // auto_detect

1346 GURL(), // pac_url

1347 ProxyRulesExpectation::PerScheme(

1348 "www.google.com:80", // http

1349 "", // https

1350 "", // ftp

1351 ""), // bypass rules

1352 },

1353

1354 {

1355 TEST_DESC("Handle blank lines and mixed line endings"),

1356

1357 // Input.

1358 "[Proxy Settings]\r\n\nProxyType=1\n\r\nhttpProxy=www.google.com\n\n",

1359 {}, // env_values

1360

1361 // Expected result.

1362 ProxyConfigService::CONFIG_VALID,

1363 false, // auto_detect

1364 GURL(), // pac_url

1365 ProxyRulesExpectation::PerScheme(

1366 "www.google.com:80", // http

1367 "", // https

1368 "", // ftp

1369 ""), // bypass rules

1370 },

1371

1372 {

1373 TEST_DESC("Handle localized settings"),

1374

1375 // Input.

1376 "[Proxy Settings]\nProxyType[$e]=1\nhttpProxy[$e]=www.google.com\n",

1377 {}, // env_values

1378

1379 // Expected result.

1380 ProxyConfigService::CONFIG_VALID,

1381 false, // auto_detect

1382 GURL(), // pac_url

1383 ProxyRulesExpectation::PerScheme(

1384 "www.google.com:80", // http

1385 "", // https

1386 "", // ftp

1387 ""), // bypass rules

1388 },

1389

1390 {

1391 TEST_DESC("Ignore malformed localized settings"),

1392

1393 // Input.

1394 "[Proxy Settings]\nProxyType=1\nhttpProxy=www.google.com\n"

1395 "httpsProxy$e]=www.foo.com\nftpProxy=ftp.foo.com\n",

1396 {}, // env_values

1397

1398 // Expected result.

1399 ProxyConfigService::CONFIG_VALID,

1400 false, // auto_detect

1401 GURL(), // pac_url

1402 ProxyRulesExpectation::PerScheme(

1403 "www.google.com:80", // http

1404 "", // https

1405 "ftp.foo.com:80", // ftp

1406 ""), // bypass rules

1407 },

1408

1409 {

1410 TEST_DESC("Handle strange whitespace"),

1411

1412 // Input.

1413 "[Proxy Settings]\nProxyType [$e] =2\n"

1414 " Proxy Config Script = http:// foo\n",

1415 {}, // env_values

1416

1417 // Expected result.

1418 ProxyConfigService::CONFIG_VALID,

1419 false, // auto_detect

1420 GURL("http:// foo"), // pac_url

1421 ProxyRulesExpectation::Empty(),

1422 },

1423

1424 {

1425 TEST_DESC("Ignore all of a line which is too long"),

1426

1427 // Input.

1428 std::string("[Proxy Settings]\nProxyType=1\nftpProxy=ftp.foo.com\n") +

1429 long_line + "httpsProxy=www.foo.com\nhttpProxy=www.google.com\n",

1430 {}, // env_values

1431

1432 // Expected result.

1433 ProxyConfigService::CONFIG_VALID,

1434 false, // auto_detect

1435 GURL(), // pac_url

1436 ProxyRulesExpectation::PerScheme(

1437 "www.google.com:80", // http

1438 "", // https

1439 "ftp.foo.com:80", // ftp

1440 ""), // bypass rules

1441 },

1442

1443 {

1444 TEST_DESC("Indirect Proxy - no env vars set"),

1445

1446 // Input.

1447 "[Proxy Settings]\nProxyType=4\nhttpProxy=http_proxy\n"

1448 "httpsProxy=https_proxy\nftpProxy=ftp_proxy\nNoProxyFor=no_proxy\n",

1449 {}, // env_values

1450

1451 // Expected result.

1452 ProxyConfigService::CONFIG_VALID,

1453 false, // auto_detect

1454 GURL(), // pac_url

1455 ProxyRulesExpectation::Empty(),

1456 },

1457

1458 {

1459 TEST_DESC("Indirect Proxy - with env vars set"),

1460

1461 // Input.

1462 "[Proxy Settings]\nProxyType=4\nhttpProxy=http_proxy\n"

1463 "httpsProxy=https_proxy\nftpProxy=ftp_proxy\nNoProxyFor=no_proxy\n",

1464 { // env_values

1465 NULL, // DESKTOP_SESSION

1466 NULL, // HOME

1467 NULL, // KDEHOME

1468 NULL, // KDE_SESSION_VERSION

1469 NULL, // auto_proxy

1470 NULL, // all_proxy

1471 "www.normal.com", // http_proxy

1472 "www.secure.com", // https_proxy

1473 "ftp.foo.com", // ftp_proxy

1474 NULL, NULL, // SOCKS

1475 ".google.com, .kde.org", // no_proxy

1476 },

1477

1478 // Expected result.

1479 ProxyConfigService::CONFIG_VALID,

1480 false, // auto_detect

1481 GURL(), // pac_url

1482 ProxyRulesExpectation::PerScheme(

1483 "www.normal.com:80", // http

1484 "www.secure.com:80", // https

1485 "ftp.foo.com:80", // ftp

1486 ".google.com,.kde.org"), // bypass rules

1487 },

1488

1489 };

1490

1491 for (size_t i = 0; i < arraysize(tests); ++i) {

1492 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,

1493 tests[i].description.c_str()));

1494 MockEnvironment* env = new MockEnvironment;

1495 env->values = tests[i].env_values;

1496 // Force the KDE getter to be used and tell it where the test is.

1497 env->values.DESKTOP_SESSION = "kde4";

1498 env->values.KDEHOME = kde_home_.value().c_str();

1499 SynchConfigGetter sync_config_getter(

1500 new ProxyConfigServiceLinux(env));

1501 ProxyConfig config;

1502 // Overwrite the kioslaverc file.

1503 base::WriteFile(kioslaverc_, tests[i].kioslaverc.c_str(),

1504 tests[i].kioslaverc.length());

1505 sync_config_getter.SetupAndInitialFetch();

1506 ProxyConfigService::ConfigAvailability availability =

1507 sync_config_getter.SyncGetLatestProxyConfig(&config);

1508 EXPECT_EQ(tests[i].availability, availability);

1509

1510 if (availability == ProxyConfigService::CONFIG_VALID) {

1511 EXPECT_EQ(tests[i].auto_detect, config.auto_detect());

1512 EXPECT_EQ(tests[i].pac_url, config.pac_url());

1513 EXPECT_TRUE(tests[i].proxy_rules.Matches(config.proxy_rules()));

1514 }

1515 }

1516 }

1517

1518 TEST_F(ProxyConfigServiceLinuxTest, KDEHomePicker) {

1519 // Auto detect proxy settings.

1520 std::string slaverc3 = "[Proxy Settings]\nProxyType=3\n";

1521 // Valid PAC URL.

1522 std::string slaverc4 = "[Proxy Settings]\nProxyType=2\n"

1523 "Proxy Config Script=http://wpad/wpad.dat\n";

1524 GURL slaverc4_pac_url("http://wpad/wpad.dat");

1525

1526 // Overwrite the .kde kioslaverc file.

1527 base::WriteFile(kioslaverc_, slaverc3.c_str(), slaverc3.length());

1528

1529 // If .kde4 exists it will mess up the first test. It should not, as

1530 // we created the directory for $HOME in the test setup.

1531 CHECK(!base::DirectoryExists(kde4_home_));

1532

1533 { SCOPED_TRACE("KDE4, no .kde4 directory, verify fallback");

1534 MockEnvironment* env = new MockEnvironment;

1535 env->values.DESKTOP_SESSION = "kde4";

1536 env->values.HOME = user_home_.value().c_str();

1537 SynchConfigGetter sync_config_getter(

1538 new ProxyConfigServiceLinux(env));

1539 ProxyConfig config;

1540 sync_config_getter.SetupAndInitialFetch();

1541 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1542 sync_config_getter.SyncGetLatestProxyConfig(&config));

1543 EXPECT_TRUE(config.auto_detect());

1544 EXPECT_EQ(GURL(), config.pac_url());

1545 }

1546

1547 // Now create .kde4 and put a kioslaverc in the config directory.

1548 // Note that its timestamp will be at least as new as the .kde one.

1549 base::CreateDirectory(kde4_config_);

1550 base::WriteFile(kioslaverc4_, slaverc4.c_str(), slaverc4.length());

1551 CHECK(base::PathExists(kioslaverc4_));

1552

1553 { SCOPED_TRACE("KDE4, .kde4 directory present, use it");

1554 MockEnvironment* env = new MockEnvironment;

1555 env->values.DESKTOP_SESSION = "kde4";

1556 env->values.HOME = user_home_.value().c_str();

1557 SynchConfigGetter sync_config_getter(

1558 new ProxyConfigServiceLinux(env));

1559 ProxyConfig config;

1560 sync_config_getter.SetupAndInitialFetch();

1561 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1562 sync_config_getter.SyncGetLatestProxyConfig(&config));

1563 EXPECT_FALSE(config.auto_detect());

1564 EXPECT_EQ(slaverc4_pac_url, config.pac_url());

1565 }

1566

1567 { SCOPED_TRACE("KDE3, .kde4 directory present, ignore it");

1568 MockEnvironment* env = new MockEnvironment;

1569 env->values.DESKTOP_SESSION = "kde";

1570 env->values.HOME = user_home_.value().c_str();

1571 SynchConfigGetter sync_config_getter(

1572 new ProxyConfigServiceLinux(env));

1573 ProxyConfig config;

1574 sync_config_getter.SetupAndInitialFetch();

1575 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1576 sync_config_getter.SyncGetLatestProxyConfig(&config));

1577 EXPECT_TRUE(config.auto_detect());

1578 EXPECT_EQ(GURL(), config.pac_url());

1579 }

1580

1581 { SCOPED_TRACE("KDE4, .kde4 directory present, KDEHOME set to .kde");

1582 MockEnvironment* env = new MockEnvironment;

1583 env->values.DESKTOP_SESSION = "kde4";

1584 env->values.HOME = user_home_.value().c_str();

1585 env->values.KDEHOME = kde_home_.value().c_str();

1586 SynchConfigGetter sync_config_getter(

1587 new ProxyConfigServiceLinux(env));

1588 ProxyConfig config;

1589 sync_config_getter.SetupAndInitialFetch();

1590 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1591 sync_config_getter.SyncGetLatestProxyConfig(&config));

1592 EXPECT_TRUE(config.auto_detect());

1593 EXPECT_EQ(GURL(), config.pac_url());

1594 }

1595

1596 // Finally, make the .kde4 config directory older than the .kde directory

1597 // and make sure we then use .kde instead of .kde4 since it's newer.

1598 base::TouchFile(kde4_config_, base::Time(), base::Time());

1599

1600 { SCOPED_TRACE("KDE4, very old .kde4 directory present, use .kde");

1601 MockEnvironment* env = new MockEnvironment;

1602 env->values.DESKTOP_SESSION = "kde4";

1603 env->values.HOME = user_home_.value().c_str();

1604 SynchConfigGetter sync_config_getter(

1605 new ProxyConfigServiceLinux(env));

1606 ProxyConfig config;

1607 sync_config_getter.SetupAndInitialFetch();

1608 EXPECT_EQ(ProxyConfigService::CONFIG_VALID,

1609 sync_config_getter.SyncGetLatestProxyConfig(&config));

1610 EXPECT_TRUE(config.auto_detect());

1611 EXPECT_EQ(GURL(), config.pac_url());

1612 }

1613 }

1614

1615 } // namespace net

OLD	NEW

« no previous file with comments | « net/proxy/proxy_config_service_linux.cc ('k') | net/proxy/proxy_config_service_mac.h » ('j') | no next file with comments »