Index: net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc |
=================================================================== |
--- net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc (revision 85647) |
+++ net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc (working copy) |
@@ -1,545 +0,0 @@ |
-// 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 { |
- 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 |