OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2011 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/dhcp_proxy_script_adapter_fetcher_win.h" |
| 6 |
| 7 #include "base/perftimer.h" |
| 8 #include "base/synchronization/waitable_event.h" |
| 9 #include "base/timer.h" |
| 10 #include "net/base/net_errors.h" |
| 11 #include "net/base/test_completion_callback.h" |
| 12 #include "net/proxy/mock_proxy_script_fetcher.h" |
| 13 #include "net/proxy/proxy_script_fetcher_impl.h" |
| 14 #include "net/test/test_server.h" |
| 15 #include "net/url_request/url_request_test_util.h" |
| 16 #include "testing/gtest/include/gtest/gtest.h" |
| 17 |
| 18 namespace net { |
| 19 |
| 20 namespace { |
| 21 |
| 22 const char* const kPacUrl = "http://pacserver/script.pac"; |
| 23 |
| 24 // In net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc there are a few |
| 25 // tests that exercise DhcpProxyScriptAdapterFetcher end-to-end along with |
| 26 // DhcpProxyScriptFetcherWin, i.e. it tests the end-to-end usage of Win32 |
| 27 // APIs and the network. In this file we test only by stubbing out |
| 28 // functionality. |
| 29 |
| 30 // Version of DhcpProxyScriptAdapterFetcher that mocks out dependencies |
| 31 // to allow unit testing. |
| 32 class MockDhcpProxyScriptAdapterFetcher |
| 33 : public DhcpProxyScriptAdapterFetcher { |
| 34 public: |
| 35 explicit MockDhcpProxyScriptAdapterFetcher(URLRequestContext* context) |
| 36 : DhcpProxyScriptAdapterFetcher(context), |
| 37 dhcp_delay_ms_(1), |
| 38 timeout_ms_(100), |
| 39 configured_url_(kPacUrl), |
| 40 fetcher_delay_ms_(1), |
| 41 fetcher_result_(OK), |
| 42 pac_script_("bingo") { |
| 43 } |
| 44 |
| 45 void Cancel() { |
| 46 DhcpProxyScriptAdapterFetcher::Cancel(); |
| 47 fetcher_ = NULL; |
| 48 } |
| 49 |
| 50 virtual ProxyScriptFetcher* ImplCreateScriptFetcher() OVERRIDE { |
| 51 // We don't maintain ownership of the fetcher, it is transferred to |
| 52 // the caller. |
| 53 fetcher_ = new MockProxyScriptFetcher(); |
| 54 if (fetcher_delay_ms_ != -1) { |
| 55 fetcher_timer_.Start( |
| 56 base::TimeDelta::FromMilliseconds(fetcher_delay_ms_), |
| 57 this, &MockDhcpProxyScriptAdapterFetcher::OnFetcherTimer); |
| 58 } |
| 59 return fetcher_; |
| 60 } |
| 61 |
| 62 class DelayingWorkerThread : public WorkerThread { |
| 63 public: |
| 64 explicit DelayingWorkerThread( |
| 65 const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner) |
| 66 : WorkerThread(owner), |
| 67 test_finished_event_(true, false) { |
| 68 } |
| 69 |
| 70 std::string ImplGetPacURLFromDhcp( |
| 71 const std::string& adapter_name) OVERRIDE { |
| 72 PerfTimer timer; |
| 73 test_finished_event_.TimedWait(dhcp_delay_); |
| 74 return configured_url_; |
| 75 } |
| 76 |
| 77 base::WaitableEvent test_finished_event_; |
| 78 TimeDelta dhcp_delay_; |
| 79 std::string configured_url_; |
| 80 }; |
| 81 |
| 82 virtual WorkerThread* ImplCreateWorkerThread( |
| 83 const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner) OVERRIDE { |
| 84 worker_thread_ = new DelayingWorkerThread(owner); |
| 85 worker_thread_->dhcp_delay_ = TimeDelta::FromMilliseconds(dhcp_delay_ms_); |
| 86 worker_thread_->configured_url_ = configured_url_; |
| 87 return worker_thread_; |
| 88 } |
| 89 |
| 90 // Use a shorter timeout so tests can finish more quickly. |
| 91 virtual base::TimeDelta ImplGetTimeout() const OVERRIDE { |
| 92 return base::TimeDelta::FromMilliseconds(timeout_ms_); |
| 93 } |
| 94 |
| 95 void OnFetcherTimer() { |
| 96 // Note that there is an assumption by this mock implementation that |
| 97 // DhcpProxyScriptAdapterFetcher::Fetch will call ImplCreateScriptFetcher |
| 98 // and call Fetch on the fetcher before the message loop is re-entered. |
| 99 // This holds true today, but if you hit this DCHECK the problem can |
| 100 // possibly be resolved by having a separate subclass of |
| 101 // MockProxyScriptFetcher that adds the delay internally (instead of |
| 102 // the simple approach currently used in ImplCreateScriptFetcher above). |
| 103 DCHECK(fetcher_ && fetcher_->has_pending_request()); |
| 104 fetcher_->NotifyFetchCompletion(fetcher_result_, pac_script_); |
| 105 fetcher_ = NULL; |
| 106 } |
| 107 |
| 108 bool IsWaitingForFetcher() const { |
| 109 return state_ == STATE_WAIT_URL; |
| 110 } |
| 111 |
| 112 bool WasCancelled() const { |
| 113 return state_ == STATE_CANCEL; |
| 114 } |
| 115 |
| 116 void FinishTest() { |
| 117 DCHECK(worker_thread_); |
| 118 worker_thread_->test_finished_event_.Signal(); |
| 119 } |
| 120 |
| 121 int dhcp_delay_ms_; |
| 122 int timeout_ms_; |
| 123 std::string configured_url_; |
| 124 int fetcher_delay_ms_; |
| 125 int fetcher_result_; |
| 126 std::string pac_script_; |
| 127 MockProxyScriptFetcher* fetcher_; |
| 128 base::OneShotTimer<MockDhcpProxyScriptAdapterFetcher> fetcher_timer_; |
| 129 scoped_refptr<DelayingWorkerThread> worker_thread_; |
| 130 }; |
| 131 |
| 132 class FetcherClient { |
| 133 public: |
| 134 FetcherClient() |
| 135 : url_request_context_(new TestURLRequestContext()), |
| 136 fetcher_( |
| 137 new MockDhcpProxyScriptAdapterFetcher(url_request_context_.get())) { |
| 138 } |
| 139 |
| 140 void WaitForResult(int expected_error) { |
| 141 EXPECT_EQ(expected_error, callback_.WaitForResult()); |
| 142 } |
| 143 |
| 144 void RunTest() { |
| 145 fetcher_->Fetch("adapter name", &callback_); |
| 146 } |
| 147 |
| 148 void FinishTestAllowCleanup() { |
| 149 fetcher_->FinishTest(); |
| 150 MessageLoop::current()->RunAllPending(); |
| 151 } |
| 152 |
| 153 TestCompletionCallback callback_; |
| 154 scoped_refptr<URLRequestContext> url_request_context_; |
| 155 scoped_ptr<MockDhcpProxyScriptAdapterFetcher> fetcher_; |
| 156 string16 pac_text_; |
| 157 }; |
| 158 |
| 159 TEST(DhcpProxyScriptAdapterFetcher, NormalCaseURLNotInDhcp) { |
| 160 FetcherClient client; |
| 161 client.fetcher_->configured_url_ = ""; |
| 162 client.RunTest(); |
| 163 client.WaitForResult(ERR_PAC_NOT_IN_DHCP); |
| 164 ASSERT_TRUE(client.fetcher_->DidFinish()); |
| 165 EXPECT_EQ(ERR_PAC_NOT_IN_DHCP, client.fetcher_->GetResult()); |
| 166 EXPECT_EQ(string16(L""), client.fetcher_->GetPacScript()); |
| 167 } |
| 168 |
| 169 TEST(DhcpProxyScriptAdapterFetcher, NormalCaseURLInDhcp) { |
| 170 FetcherClient client; |
| 171 client.RunTest(); |
| 172 client.WaitForResult(OK); |
| 173 ASSERT_TRUE(client.fetcher_->DidFinish()); |
| 174 EXPECT_EQ(OK, client.fetcher_->GetResult()); |
| 175 EXPECT_EQ(string16(L"bingo"), client.fetcher_->GetPacScript()); |
| 176 EXPECT_EQ(GURL(kPacUrl), client.fetcher_->GetPacURL()); |
| 177 } |
| 178 |
| 179 TEST(DhcpProxyScriptAdapterFetcher, TimeoutDuringDhcp) { |
| 180 // Does a Fetch() with a long enough delay on accessing DHCP that the |
| 181 // fetcher should time out. This is to test a case manual testing found, |
| 182 // where under certain circumstances (e.g. adapter enabled for DHCP and |
| 183 // needs to retrieve its configuration from DHCP, but no DHCP server |
| 184 // present on the network) accessing DHCP can take on the order of tens |
| 185 // of seconds. |
| 186 FetcherClient client; |
| 187 client.fetcher_->dhcp_delay_ms_ = 20 * 1000; |
| 188 client.fetcher_->timeout_ms_ = 25; |
| 189 |
| 190 PerfTimer timer; |
| 191 client.RunTest(); |
| 192 client.WaitForResult(ERR_TIMED_OUT); |
| 193 |
| 194 // The timeout should occur within about 25 ms, way before the 20s set as |
| 195 // the API delay above. |
| 196 ASSERT_GT(base::TimeDelta::FromMilliseconds(35), timer.Elapsed()); |
| 197 ASSERT_TRUE(client.fetcher_->DidFinish()); |
| 198 EXPECT_EQ(ERR_TIMED_OUT, client.fetcher_->GetResult()); |
| 199 EXPECT_EQ(string16(L""), client.fetcher_->GetPacScript()); |
| 200 EXPECT_EQ(GURL(), client.fetcher_->GetPacURL()); |
| 201 client.FinishTestAllowCleanup(); |
| 202 } |
| 203 |
| 204 TEST(DhcpProxyScriptAdapterFetcher, CancelWhileDhcp) { |
| 205 FetcherClient client; |
| 206 client.fetcher_->dhcp_delay_ms_ = 10; |
| 207 client.RunTest(); |
| 208 client.fetcher_->Cancel(); |
| 209 MessageLoop::current()->RunAllPending(); |
| 210 ASSERT_FALSE(client.fetcher_->DidFinish()); |
| 211 ASSERT_TRUE(client.fetcher_->WasCancelled()); |
| 212 EXPECT_EQ(ERR_ABORTED, client.fetcher_->GetResult()); |
| 213 EXPECT_EQ(string16(L""), client.fetcher_->GetPacScript()); |
| 214 EXPECT_EQ(GURL(), client.fetcher_->GetPacURL()); |
| 215 client.FinishTestAllowCleanup(); |
| 216 } |
| 217 |
| 218 TEST(DhcpProxyScriptAdapterFetcher, CancelWhileFetcher) { |
| 219 FetcherClient client; |
| 220 // This causes the mock fetcher not to pretend the |
| 221 // fetcher finishes after a timeout. |
| 222 client.fetcher_->fetcher_delay_ms_ = -1; |
| 223 client.RunTest(); |
| 224 int max_loops = 4; |
| 225 while (!client.fetcher_->IsWaitingForFetcher() && max_loops--) { |
| 226 base::PlatformThread::Sleep(10); |
| 227 MessageLoop::current()->RunAllPending(); |
| 228 } |
| 229 client.fetcher_->Cancel(); |
| 230 MessageLoop::current()->RunAllPending(); |
| 231 ASSERT_FALSE(client.fetcher_->DidFinish()); |
| 232 ASSERT_TRUE(client.fetcher_->WasCancelled()); |
| 233 EXPECT_EQ(ERR_ABORTED, client.fetcher_->GetResult()); |
| 234 EXPECT_EQ(string16(L""), client.fetcher_->GetPacScript()); |
| 235 // GetPacURL() still returns the URL fetched in this case. |
| 236 EXPECT_EQ(GURL(kPacUrl), client.fetcher_->GetPacURL()); |
| 237 client.FinishTestAllowCleanup(); |
| 238 } |
| 239 |
| 240 TEST(DhcpProxyScriptAdapterFetcher, CancelAtCompletion) { |
| 241 FetcherClient client; |
| 242 client.RunTest(); |
| 243 client.WaitForResult(OK); |
| 244 client.fetcher_->Cancel(); |
| 245 // Canceling after you're done should have no effect, so these |
| 246 // are identical expectations to the NormalCaseURLInDhcp test. |
| 247 ASSERT_TRUE(client.fetcher_->DidFinish()); |
| 248 EXPECT_EQ(OK, client.fetcher_->GetResult()); |
| 249 EXPECT_EQ(string16(L"bingo"), client.fetcher_->GetPacScript()); |
| 250 EXPECT_EQ(GURL(kPacUrl), client.fetcher_->GetPacURL()); |
| 251 client.FinishTestAllowCleanup(); |
| 252 } |
| 253 |
| 254 // Does a real fetch on a mock DHCP configuration. |
| 255 class MockDhcpRealFetchProxyScriptAdapterFetcher |
| 256 : public MockDhcpProxyScriptAdapterFetcher { |
| 257 public: |
| 258 explicit MockDhcpRealFetchProxyScriptAdapterFetcher( |
| 259 URLRequestContext* context) |
| 260 : MockDhcpProxyScriptAdapterFetcher(context), |
| 261 url_request_context_(context) { |
| 262 } |
| 263 |
| 264 // Returns a real proxy script fetcher. |
| 265 ProxyScriptFetcher* ImplCreateScriptFetcher() OVERRIDE { |
| 266 ProxyScriptFetcher* fetcher = |
| 267 new ProxyScriptFetcherImpl(url_request_context_); |
| 268 return fetcher; |
| 269 } |
| 270 |
| 271 URLRequestContext* url_request_context_; |
| 272 }; |
| 273 |
| 274 TEST(DhcpProxyScriptAdapterFetcher, MockDhcpRealFetch) { |
| 275 TestServer test_server( |
| 276 TestServer::TYPE_HTTP, |
| 277 FilePath(FILE_PATH_LITERAL("net/data/proxy_script_fetcher_unittest"))); |
| 278 ASSERT_TRUE(test_server.Start()); |
| 279 |
| 280 GURL configured_url = test_server.GetURL("files/downloadable.pac"); |
| 281 |
| 282 FetcherClient client; |
| 283 scoped_refptr<URLRequestContext> url_request_context( |
| 284 new TestURLRequestContext()); |
| 285 client.fetcher_.reset( |
| 286 new MockDhcpRealFetchProxyScriptAdapterFetcher( |
| 287 url_request_context.get())); |
| 288 client.fetcher_->configured_url_ = configured_url.spec(); |
| 289 client.RunTest(); |
| 290 client.WaitForResult(OK); |
| 291 ASSERT_TRUE(client.fetcher_->DidFinish()); |
| 292 EXPECT_EQ(OK, client.fetcher_->GetResult()); |
| 293 EXPECT_EQ(string16(L"-downloadable.pac-\n"), client.fetcher_->GetPacScript()); |
| 294 EXPECT_EQ(configured_url, |
| 295 client.fetcher_->GetPacURL()); |
| 296 } |
| 297 |
| 298 } // namespace |
| 299 |
| 300 } // namespace net |
OLD | NEW |