Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1382)

Unified Diff: net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc

Issue 6831025: Adds support for the DHCP portion of the WPAD (proxy auto-discovery) protocol. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Fix memory leaks in unit test. Created 9 years, 7 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/proxy/dhcp_proxy_script_fetcher_win.cc ('k') | net/proxy/dhcpcsvc_init_win.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc
diff --git a/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc b/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..596e298fdf257a292479933f3f1a5983a4b0cb43
--- /dev/null
+++ b/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc
@@ -0,0 +1,545 @@
+// Copyright (c) 2011 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/proxy/dhcp_proxy_script_fetcher_win.h"
+
+#include <vector>
+
+#include "base/message_loop.h"
+#include "base/perftimer.h"
+#include "base/rand_util.h"
+#include "base/threading/platform_thread.h"
+#include "net/base/completion_callback.h"
+#include "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+TEST(DhcpProxyScriptFetcherWin, AdapterNamesAndPacURLFromDhcp) {
+ // This tests our core Win32 implementation without any of the wrappers
+ // we layer on top to achieve asynchronous and parallel operations.
+ //
+ // We don't make assumptions about the environment this unit test is
+ // running in, so it just exercises the code to make sure there
+ // is no crash and no error returned, but does not assert on the number
+ // of interfaces or the information returned via DHCP.
+ std::set<std::string> adapter_names;
+ DhcpProxyScriptFetcherWin::GetCandidateAdapterNames(&adapter_names);
+ for (std::set<std::string>::const_iterator it = adapter_names.begin();
+ it != adapter_names.end();
+ ++it) {
+ const std::string& adapter_name = *it;
+ std::string pac_url =
+ DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(adapter_name);
+ printf("Adapter '%s' has PAC URL '%s' configured in DHCP.\n",
+ adapter_name.c_str(),
+ pac_url.c_str());
+ }
+}
+
+// Helper for RealFetch* tests below.
+class RealFetchTester {
+ public:
+ RealFetchTester()
+ : context_((new TestURLRequestContext())),
+ fetcher_(new DhcpProxyScriptFetcherWin(context_.get())),
+ finished_(false),
+ ALLOW_THIS_IN_INITIALIZER_LIST(
+ completion_callback_(this, &RealFetchTester::OnCompletion)),
+ on_completion_is_error_(false) {
+ // Make sure the test ends.
+ timeout_.Start(
+ base::TimeDelta::FromSeconds(5), this, &RealFetchTester::OnTimeout);
+ }
+
+ void RunTest() {
+ fetcher_->Fetch(&pac_text_, &completion_callback_);
+ }
+
+ void RunTestWithCancel() {
+ RunTest();
+ fetcher_->Cancel();
+ }
+
+ void RunTestWithDeferredCancel() {
+ RunTest();
+ cancel_timer_.Start(base::TimeDelta::FromMilliseconds(1),
+ this, &RealFetchTester::OnCancelTimer);
+ }
+
+ void OnCompletion(int result) {
+ if (on_completion_is_error_) {
+ FAIL() << "Received completion for test in which this is error.";
+ }
+ finished_ = true;
+ printf("Result code %d PAC data length %d\n", result, pac_text_.size());
+ }
+
+ void OnTimeout() {
+ printf("Timeout!");
+ OnCompletion(0);
+ }
+
+ void OnCancelTimer() {
+ fetcher_->Cancel();
+ finished_ = true;
+ }
+
+ void WaitUntilDone() {
+ while (!finished_) {
+ MessageLoop::current()->RunAllPending();
+ }
+ MessageLoop::current()->RunAllPending();
+ }
+
+ // Attempts to give worker threads time to finish. This is currently
+ // very simplistic as completion (via completion callback or cancellation)
+ // immediately "detaches" any worker threads, so the best we can do is give
+ // them a little time. If we start running into Valgrind leaks, we can
+ // do something a bit more clever to track worker threads even when the
+ // DhcpProxyScriptFetcherWin state machine has finished.
+ void FinishTestAllowCleanup() {
+ base::PlatformThread::Sleep(30);
+ }
+
+ scoped_refptr<URLRequestContext> context_;
+ scoped_ptr<DhcpProxyScriptFetcherWin> fetcher_;
+ bool finished_;
+ string16 pac_text_;
+ CompletionCallbackImpl<RealFetchTester> completion_callback_;
+ base::OneShotTimer<RealFetchTester> timeout_;
+ base::OneShotTimer<RealFetchTester> cancel_timer_;
+ bool on_completion_is_error_;
+};
+
+TEST(DhcpProxyScriptFetcherWin, RealFetch) {
+ // This tests a call to Fetch() with no stubbing out of dependencies.
+ //
+ // We don't make assumptions about the environment this unit test is
+ // running in, so it just exercises the code to make sure there
+ // is no crash and no unexpected error returned, but does not assert on
+ // results beyond that.
+ RealFetchTester fetcher;
+ fetcher.RunTest();
+
+ fetcher.WaitUntilDone();
+ printf("PAC URL was %s\n",
+ fetcher.fetcher_->GetPacURL().possibly_invalid_spec().c_str());
+
+ fetcher.FinishTestAllowCleanup();
+}
+
+TEST(DhcpProxyScriptFetcherWin, RealFetchWithCancel) {
+ // Does a Fetch() with an immediate cancel. As before, just
+ // exercises the code without stubbing out dependencies.
+ RealFetchTester fetcher;
+ fetcher.RunTestWithCancel();
+ MessageLoop::current()->RunAllPending();
+
+ // Attempt to avoid Valgrind leak reports in case worker thread is
+ // still running.
+ fetcher.FinishTestAllowCleanup();
+}
+
+// For RealFetchWithDeferredCancel, below.
+class DelayingDhcpProxyScriptAdapterFetcher
+ : public DhcpProxyScriptAdapterFetcher {
+ public:
+ explicit DelayingDhcpProxyScriptAdapterFetcher(
+ URLRequestContext* url_request_context)
+ : DhcpProxyScriptAdapterFetcher(url_request_context) {
+ }
+
+ class DelayingWorkerThread : public WorkerThread {
+ public:
+ explicit DelayingWorkerThread(
+ const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner)
+ : WorkerThread(owner) {
+ }
+
+ std::string ImplGetPacURLFromDhcp(
+ const std::string& adapter_name) OVERRIDE {
+ base::PlatformThread::Sleep(20);
+ return WorkerThread::ImplGetPacURLFromDhcp(adapter_name);
+ }
+ };
+
+ WorkerThread* ImplCreateWorkerThread(
+ const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner) OVERRIDE {
+ return new DelayingWorkerThread(owner);
+ }
+};
+
+// For RealFetchWithDeferredCancel, below.
+class DelayingDhcpProxyScriptFetcherWin
+ : public DhcpProxyScriptFetcherWin {
+ public:
+ explicit DelayingDhcpProxyScriptFetcherWin(
+ URLRequestContext* context)
+ : DhcpProxyScriptFetcherWin(context) {
+ }
+
+ DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
+ return new DelayingDhcpProxyScriptAdapterFetcher(url_request_context_);
+ }
+};
+
+TEST(DhcpProxyScriptFetcherWin, RealFetchWithDeferredCancel) {
+ // Does a Fetch() with a slightly delayed cancel. As before, just
+ // exercises the code without stubbing out dependencies, but
+ // introduces a guaranteed 20 ms delay on the worker threads so that
+ // the cancel is called before they complete.
+ RealFetchTester fetcher;
+ fetcher.fetcher_.reset(
+ new DelayingDhcpProxyScriptFetcherWin(fetcher.context_));
+ fetcher.on_completion_is_error_ = true;
+ fetcher.RunTestWithDeferredCancel();
+ fetcher.WaitUntilDone();
+}
+
+// The remaining tests are to exercise our state machine in various
+// situations, with actual network access fully stubbed out.
+
+class DummyDhcpProxyScriptAdapterFetcher
+ : public DhcpProxyScriptAdapterFetcher {
+ public:
+ DummyDhcpProxyScriptAdapterFetcher()
+ : DhcpProxyScriptAdapterFetcher(new TestURLRequestContext()),
+ did_finish_(false),
+ result_(OK),
+ pac_script_(L"bingo"),
+ fetch_delay_ms_(1),
+ client_callback_(NULL) {
+ }
+
+ void Fetch(const std::string& adapter_name,
+ CompletionCallback* callback) OVERRIDE {
+ client_callback_ = callback;
+ timer_.Start(base::TimeDelta::FromMilliseconds(fetch_delay_ms_),
+ this, &DummyDhcpProxyScriptAdapterFetcher::OnTimer);
+ }
+
+ void Cancel() OVERRIDE {
Timur Iskhodzhanov 2011/06/27 14:44:01 FYI, You're overriding the Cancel() method which i
Jói 2011/06/27 15:19:06 Thanks, yes I'm aware. I only need to stop the ti
+ timer_.Stop();
+ }
+
+ bool DidFinish() const OVERRIDE {
+ return did_finish_;
+ }
+
+ int GetResult() const OVERRIDE {
+ return result_;
+ }
+
+ string16 GetPacScript() const OVERRIDE {
+ return pac_script_;
+ }
+
+ void OnTimer() {
+ client_callback_->Run(result_);
+ }
+
+ void Configure(
+ bool did_finish, int result, string16 pac_script, int fetch_delay_ms) {
+ did_finish_ = did_finish;
+ result_ = result;
+ pac_script_ = pac_script;
+ fetch_delay_ms_ = fetch_delay_ms;
+ }
+
+ private:
+ bool did_finish_;
+ int result_;
+ string16 pac_script_;
+ int fetch_delay_ms_;
+ CompletionCallback* client_callback_;
+ base::OneShotTimer<DummyDhcpProxyScriptAdapterFetcher> timer_;
+};
+
+class MockDhcpProxyScriptFetcherWin : public DhcpProxyScriptFetcherWin {
+ public:
+ MockDhcpProxyScriptFetcherWin()
+ : DhcpProxyScriptFetcherWin(new TestURLRequestContext()),
+ next_adapter_fetcher_index_(0) {
+ }
+
+ // Adds a fetcher object to the queue of fetchers used by
+ // |ImplCreateAdapterFetcher()|, and its name to the list of adapters
+ // returned by ImplGetCandidateAdapterNames.
+ void PushBackAdapter(const std::string& adapter_name,
+ DhcpProxyScriptAdapterFetcher* fetcher) {
+ adapter_names_.push_back(adapter_name);
+ adapter_fetchers_.push_back(fetcher);
+ }
+
+ void ConfigureAndPushBackAdapter(const std::string& adapter_name,
+ bool did_finish,
+ int result,
+ string16 pac_script,
+ int fetch_delay_ms) {
+ scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
+ new DummyDhcpProxyScriptAdapterFetcher());
+ adapter_fetcher->Configure(did_finish, result, pac_script, fetch_delay_ms);
+ PushBackAdapter(adapter_name, adapter_fetcher.release());
+ }
+
+ DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
+ return adapter_fetchers_[next_adapter_fetcher_index_++];
+ }
+
+ bool ImplGetCandidateAdapterNames(
+ std::set<std::string>* adapter_names) OVERRIDE {
+ adapter_names->insert(adapter_names_.begin(), adapter_names_.end());
+ return true;
+ }
+
+ int ImplGetMaxWaitMs() OVERRIDE {
+ return 25;
+ }
+
+ void ResetTestState() {
+ next_adapter_fetcher_index_ = 0;
+ adapter_fetchers_.clear();
+ // String pointers contained herein will have been freed during test.
+ adapter_names_.clear();
+ }
+
+ int next_adapter_fetcher_index_;
+
+ // Ownership is not here; it gets transferred to the implementation
+ // class via ImplCreateAdapterFetcher.
+ std::vector<DhcpProxyScriptAdapterFetcher*> adapter_fetchers_;
+
+ std::vector<std::string> adapter_names_;
+};
+
+class FetcherClient {
+public:
+ FetcherClient()
+ : finished_(false),
+ result_(ERR_UNEXPECTED),
+ ALLOW_THIS_IN_INITIALIZER_LIST(
+ completion_callback_(this, &FetcherClient::OnCompletion)) {
+ }
+
+ void RunTest() {
+ int result = fetcher_.Fetch(&pac_text_, &completion_callback_);
+ ASSERT_EQ(ERR_IO_PENDING, result);
+ }
+
+ void RunImmediateReturnTest() {
+ int result = fetcher_.Fetch(&pac_text_, &completion_callback_);
+ ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, result);
+ }
+
+ void RunMessageLoopUntilComplete() {
+ while (!finished_) {
+ MessageLoop::current()->RunAllPending();
+ }
+ MessageLoop::current()->RunAllPending();
+ }
+
+ void OnCompletion(int result) {
+ finished_ = true;
+ result_ = result;
+ }
+
+ void ResetTestState() {
+ finished_ = false;
+ result_ = ERR_UNEXPECTED;
+ pac_text_ = L"";
+ fetcher_.ResetTestState();
+ }
+
+ MockDhcpProxyScriptFetcherWin fetcher_;
+ bool finished_;
+ int result_;
+ string16 pac_text_;
+ CompletionCallbackImpl<FetcherClient> completion_callback_;
+};
+
+// We separate out each test's logic so that we can easily implement
+// the ReuseFetcher test at the bottom.
+void TestNormalCaseURLConfiguredOneAdapter(FetcherClient* client) {
+ scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
+ new DummyDhcpProxyScriptAdapterFetcher());
+ adapter_fetcher->Configure(true, OK, L"bingo", 1);
+ client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
+ client->RunTest();
+ client->RunMessageLoopUntilComplete();
+ ASSERT_EQ(OK, client->result_);
+ ASSERT_EQ(L"bingo", client->pac_text_);
+}
+
+TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredOneAdapter) {
+ FetcherClient client;
+ TestNormalCaseURLConfiguredOneAdapter(&client);
+}
+
+void TestNormalCaseURLConfiguredMultipleAdapters(FetcherClient* client) {
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "second", true, OK, L"bingo", 50);
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "third", true, OK, L"rocko", 1);
+ client->RunTest();
+ client->RunMessageLoopUntilComplete();
+ ASSERT_EQ(OK, client->result_);
+ ASSERT_EQ(L"bingo", client->pac_text_);
+}
+
+TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredMultipleAdapters) {
+ FetcherClient client;
+ TestNormalCaseURLConfiguredMultipleAdapters(&client);
+}
+
+void TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout(
+ FetcherClient* client) {
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+ // This will time out.
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "second", false, ERR_IO_PENDING, L"bingo", 1000);
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "third", true, OK, L"rocko", 1);
+ client->RunTest();
+ client->RunMessageLoopUntilComplete();
+ ASSERT_EQ(OK, client->result_);
+ ASSERT_EQ(L"rocko", client->pac_text_);
+}
+
+TEST(DhcpProxyScriptFetcherWin,
+ NormalCaseURLConfiguredMultipleAdaptersWithTimeout) {
+ FetcherClient client;
+ TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout(&client);
+}
+
+void TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout(
+ FetcherClient* client) {
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+ // This will time out.
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "second", false, ERR_IO_PENDING, L"bingo", 1000);
+ // This is the first non-ERR_PAC_NOT_IN_DHCP error and as such
+ // should be chosen.
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "third", true, ERR_PAC_STATUS_NOT_OK, L"", 1);
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "fourth", true, ERR_NOT_IMPLEMENTED, L"", 1);
+ client->RunTest();
+ client->RunMessageLoopUntilComplete();
+ ASSERT_EQ(ERR_PAC_STATUS_NOT_OK, client->result_);
+ ASSERT_EQ(L"", client->pac_text_);
+}
+
+TEST(DhcpProxyScriptFetcherWin,
+ FailureCaseURLConfiguredMultipleAdaptersWithTimeout) {
+ FetcherClient client;
+ TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout(&client);
+}
+
+void TestFailureCaseNoURLConfigured(FetcherClient* client) {
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+ // This will time out.
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "second", false, ERR_IO_PENDING, L"bingo", 1000);
+ // This is the first non-ERR_PAC_NOT_IN_DHCP error and as such
+ // should be chosen.
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "third", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+ client->RunTest();
+ client->RunMessageLoopUntilComplete();
+ ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, client->result_);
+ ASSERT_EQ(L"", client->pac_text_);
+}
+
+TEST(DhcpProxyScriptFetcherWin, FailureCaseNoURLConfigured) {
+ FetcherClient client;
+ TestFailureCaseNoURLConfigured(&client);
+}
+
+void TestFailureCaseNoDhcpAdapters(FetcherClient* client) {
+ client->RunImmediateReturnTest();
+ // In case there are any pending messages that get us in a bad state
+ // (there shouldn't be).
+ MessageLoop::current()->RunAllPending();
+}
+
+TEST(DhcpProxyScriptFetcherWin, FailureCaseNoDhcpAdapters) {
+ FetcherClient client;
+ TestFailureCaseNoDhcpAdapters(&client);
+}
+
+void TestShortCircuitLessPreferredAdapters(FetcherClient* client) {
+ // Here we have a bunch of adapters; the first reports no PAC in DHCP,
+ // the second responds quickly with a PAC file, the rest take a long
+ // time. Verify that we complete quickly and do not wait for the slow
+ // adapters, i.e. we finish before timeout.
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "1", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "2", true, OK, L"bingo", 1);
+ client->fetcher_.ConfigureAndPushBackAdapter(
+ "3", true, OK, L"wrongo", 1000);
+
+ PerfTimer timer;
+ client->RunTest();
+ client->RunMessageLoopUntilComplete();
+ // Assert that the time passed is just less than the wait timer
+ // timeout (which we have mocked out above to be 25 ms), to avoid
+ // flakiness but still get a strong signal that it was the shortcut
+ // mechanism (in OnFetcherDone) that kicked in.
+ ASSERT_GT(TimeDelta::FromMilliseconds(23), timer.Elapsed());
+}
+
+TEST(DhcpProxyScriptFetcherWin, ShortCircuitLessPreferredAdapters) {
+ FetcherClient client;
+ TestShortCircuitLessPreferredAdapters(&client);
+}
+
+TEST(DhcpProxyScriptFetcherWin, ReuseFetcher) {
+ FetcherClient client;
+
+ // The ProxyScriptFetcher interface stipulates that only a single
+ // |Fetch()| may be in flight at once, but allows reuse, so test
+ // that the state transitions correctly from done to start in all
+ // cases we're testing.
+
+ typedef void (*FetcherClientTestFunction)(FetcherClient*);
+ typedef std::vector<FetcherClientTestFunction> TestVector;
+ TestVector test_functions;
+ test_functions.push_back(TestNormalCaseURLConfiguredOneAdapter);
+ test_functions.push_back(TestNormalCaseURLConfiguredMultipleAdapters);
+ test_functions.push_back(
+ TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout);
+ test_functions.push_back(
+ TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout);
+ test_functions.push_back(TestFailureCaseNoURLConfigured);
+ test_functions.push_back(TestFailureCaseNoDhcpAdapters);
+ test_functions.push_back(TestShortCircuitLessPreferredAdapters);
+
+ std::random_shuffle(test_functions.begin(),
+ test_functions.end(),
+ base::RandGenerator);
+ for (TestVector::const_iterator it = test_functions.begin();
+ it != test_functions.end();
+ ++it) {
+ (*it)(&client);
+ client.ResetTestState();
+ }
+
+ // Re-do the first test to make sure the last test that was run did
+ // not leave things in a bad state.
+ (*test_functions.begin())(&client);
+}
+
+} // namespace
+
+} // namespace net
« no previous file with comments | « net/proxy/dhcp_proxy_script_fetcher_win.cc ('k') | net/proxy/dhcpcsvc_init_win.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698