net/url_request/url_request_http_job_unittest.cc

   1 // Copyright (c) 2013 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/url_request/url_request_http_job.h"
   6
   7 #include <cstddef>
   8
   9 #include "base/compiler_specific.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/run_loop.h"
  12 #include "net/base/auth.h"
  13 #include "net/base/request_priority.h"
  14 #include "net/http/http_transaction_factory.h"
  15 #include "net/http/http_transaction_test_util.h"
  16 #include "net/socket/socket_test_util.h"
  17 #include "net/url_request/url_request_status.h"
  18 #include "net/url_request/url_request_test_util.h"
  19 #include "net/websockets/websocket_handshake_stream_base.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "url/gurl.h"
  23
  24 namespace net {
  25
  26 namespace {
  27
  28 using ::testing::Return;
  29
  30 // Inherit from URLRequestHttpJob to expose the priority and some
  31 // other hidden functions.
  32 class TestURLRequestHttpJob : public URLRequestHttpJob {
  33  public:
  34   explicit TestURLRequestHttpJob(URLRequest* request)
  35       : URLRequestHttpJob(request, request->context()->network_delegate(),
  36                           request->context()->http_user_agent_settings()) {}
  37
  38   using URLRequestHttpJob::SetPriority;
  39   using URLRequestHttpJob::Start;
  40   using URLRequestHttpJob::Kill;
  41   using URLRequestHttpJob::priority;
  42
  43  protected:
  44   virtual ~TestURLRequestHttpJob() {}
  45 };
  46
  47 class URLRequestHttpJobTest : public ::testing::Test {
  48  protected:
  49   URLRequestHttpJobTest()
  50       : req_(GURL("http://www.example.com"),
  51              DEFAULT_PRIORITY,
  52              &delegate_,
  53              &context_) {
  54     context_.set_http_transaction_factory(&network_layer_);
  55   }
  56
  57   MockNetworkLayer network_layer_;
  58   TestURLRequestContext context_;
  59   TestDelegate delegate_;
  60   TestURLRequest req_;
  61 };
  62
  63 // Make sure that SetPriority actually sets the URLRequestHttpJob's
  64 // priority, both before and after start.
  65 TEST_F(URLRequestHttpJobTest, SetPriorityBasic) {
  66   scoped_refptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(&req_));
  67   EXPECT_EQ(DEFAULT_PRIORITY, job->priority());
  68
  69   job->SetPriority(LOWEST);
  70   EXPECT_EQ(LOWEST, job->priority());
  71
  72   job->SetPriority(LOW);
  73   EXPECT_EQ(LOW, job->priority());
  74
  75   job->Start();
  76   EXPECT_EQ(LOW, job->priority());
  77
  78   job->SetPriority(MEDIUM);
  79   EXPECT_EQ(MEDIUM, job->priority());
  80 }
  81
  82 // Make sure that URLRequestHttpJob passes on its priority to its
  83 // transaction on start.
  84 TEST_F(URLRequestHttpJobTest, SetTransactionPriorityOnStart) {
  85   scoped_refptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(&req_));
  86   job->SetPriority(LOW);
  87
  88   EXPECT_FALSE(network_layer_.last_transaction());
  89
  90   job->Start();
  91
  92   ASSERT_TRUE(network_layer_.last_transaction());
  93   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
  94 }
  95
  96 // Make sure that URLRequestHttpJob passes on its priority updates to
  97 // its transaction.
  98 TEST_F(URLRequestHttpJobTest, SetTransactionPriority) {
  99   scoped_refptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(&req_));
 100   job->SetPriority(LOW);
 101   job->Start();
 102   ASSERT_TRUE(network_layer_.last_transaction());
 103   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 104
 105   job->SetPriority(HIGHEST);
 106   EXPECT_EQ(HIGHEST, network_layer_.last_transaction()->priority());
 107 }
 108
 109 // Make sure that URLRequestHttpJob passes on its priority updates to
 110 // newly-created transactions after the first one.
 111 TEST_F(URLRequestHttpJobTest, SetSubsequentTransactionPriority) {
 112   scoped_refptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(&req_));
 113   job->Start();
 114
 115   job->SetPriority(LOW);
 116   ASSERT_TRUE(network_layer_.last_transaction());
 117   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 118
 119   job->Kill();
 120   network_layer_.ClearLastTransaction();
 121
 122   // Creates a second transaction.
 123   job->Start();
 124   ASSERT_TRUE(network_layer_.last_transaction());
 125   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 126 }
 127
 128 // This base class just serves to set up some things before the TestURLRequest
 129 // constructor is called.
 130 class URLRequestHttpJobWebSocketTestBase : public ::testing::Test {
 131  protected:
 132   URLRequestHttpJobWebSocketTestBase() : socket_data_(NULL, 0, NULL, 0),
 133                                          context_(true) {
 134     // A Network Delegate is required for the WebSocketHandshakeStreamBase
 135     // object to be passed on to the HttpNetworkTransaction.
 136     context_.set_network_delegate(&network_delegate_);
 137
 138     // Attempting to create real ClientSocketHandles is not going to work out so
 139     // well. Set up a fake socket factory.
 140     socket_factory_.AddSocketDataProvider(&socket_data_);
 141     context_.set_client_socket_factory(&socket_factory_);
 142     context_.Init();
 143   }
 144
 145   StaticSocketDataProvider socket_data_;
 146   TestNetworkDelegate network_delegate_;
 147   MockClientSocketFactory socket_factory_;
 148   TestURLRequestContext context_;
 149 };
 150
 151 class URLRequestHttpJobWebSocketTest
 152     : public URLRequestHttpJobWebSocketTestBase {
 153  protected:
 154   URLRequestHttpJobWebSocketTest()
 155       : req_(GURL("ws://www.example.com"),
 156              DEFAULT_PRIORITY,
 157              &delegate_,
 158              &context_) {
 159     // The TestNetworkDelegate expects a call to NotifyBeforeURLRequest before
 160     // anything else happens.
 161     GURL url("ws://localhost/");
 162     TestCompletionCallback dummy;
 163     network_delegate_.NotifyBeforeURLRequest(&req_, dummy.callback(), &url);
 164   }
 165
 166   TestDelegate delegate_;
 167   TestURLRequest req_;
 168 };
 169
 170 class MockCreateHelper : public WebSocketHandshakeStreamBase::CreateHelper {
 171  public:
 172   // GoogleMock does not appear to play nicely with move-only types like
 173   // scoped_ptr, so this forwarding method acts as a workaround.
 174   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
 175       scoped_ptr<ClientSocketHandle> connection,
 176       bool using_proxy) OVERRIDE {
 177     // Discard the arguments since we don't need them anyway.
 178     return CreateBasicStreamMock();
 179   }
 180
 181   MOCK_METHOD0(CreateBasicStreamMock,
 182                WebSocketHandshakeStreamBase*());
 183
 184   MOCK_METHOD2(CreateSpdyStream,
 185                WebSocketHandshakeStreamBase*(const base::WeakPtr<SpdySession>&,
 186                                              bool));
 187 };
 188
 189 class FakeWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
 190  public:
 191   FakeWebSocketHandshakeStream() : initialize_stream_was_called_(false) {}
 192
 193   bool initialize_stream_was_called() const {
 194     return initialize_stream_was_called_;
 195   }
 196
 197   // Fake implementation of HttpStreamBase methods.
 198   virtual int InitializeStream(const HttpRequestInfo* request_info,
 199                                RequestPriority priority,
 200                                const BoundNetLog& net_log,
 201                                const CompletionCallback& callback) OVERRIDE {
 202     initialize_stream_was_called_ = true;
 203     return ERR_IO_PENDING;
 204   }
 205
 206   virtual int SendRequest(const HttpRequestHeaders& request_headers,
 207                           HttpResponseInfo* response,
 208                           const CompletionCallback& callback) OVERRIDE {
 209     return ERR_IO_PENDING;
 210   }
 211
 212   virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
 213     return ERR_IO_PENDING;
 214   }
 215
 216   virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE {
 217     return NULL;
 218   }
 219
 220   virtual int ReadResponseBody(IOBuffer* buf,
 221                                int buf_len,
 222                                const CompletionCallback& callback) OVERRIDE {
 223     return ERR_IO_PENDING;
 224   }
 225
 226   virtual void Close(bool not_reusable) OVERRIDE {}
 227
 228   virtual bool IsResponseBodyComplete() const OVERRIDE { return false; }
 229
 230   virtual bool CanFindEndOfResponse() const OVERRIDE { return false; }
 231
 232   virtual bool IsConnectionReused() const OVERRIDE { return false; }
 233   virtual void SetConnectionReused() OVERRIDE {}
 234
 235   virtual bool IsConnectionReusable() const OVERRIDE { return false; }
 236
 237   virtual int64 GetTotalReceivedBytes() const OVERRIDE { return 0; }
 238
 239   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
 240       OVERRIDE {
 241     return false;
 242   }
 243
 244   virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
 245
 246   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
 247       OVERRIDE {}
 248
 249   virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
 250
 251   virtual void Drain(HttpNetworkSession* session) OVERRIDE {}
 252
 253   virtual void SetPriority(RequestPriority priority) OVERRIDE {}
 254
 255   // Fake implementation of WebSocketHandshakeStreamBase method(s)
 256   virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE {
 257     return scoped_ptr<WebSocketStream>();
 258   }
 259
 260   virtual std::string GetFailureMessage() const OVERRIDE {
 261     return std::string();
 262   }
 263
 264  private:
 265   bool initialize_stream_was_called_;
 266 };
 267
 268 TEST_F(URLRequestHttpJobWebSocketTest, RejectedWithoutCreateHelper) {
 269   scoped_refptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(&req_));
 270   job->Start();
 271   base::RunLoop().RunUntilIdle();
 272   EXPECT_EQ(URLRequestStatus::FAILED, req_.status().status());
 273   EXPECT_EQ(ERR_DISALLOWED_URL_SCHEME, req_.status().error());
 274 }
 275
 276 TEST_F(URLRequestHttpJobWebSocketTest, CreateHelperPassedThrough) {
 277   scoped_refptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(&req_));
 278   scoped_ptr<MockCreateHelper> create_helper(
 279       new ::testing::StrictMock<MockCreateHelper>());
 280   FakeWebSocketHandshakeStream* fake_handshake_stream(
 281       new FakeWebSocketHandshakeStream);
 282   // Ownership of fake_handshake_stream is transferred when CreateBasicStream()
 283   // is called.
 284   EXPECT_CALL(*create_helper, CreateBasicStreamMock())
 285       .WillOnce(Return(fake_handshake_stream));
 286   req_.SetUserData(WebSocketHandshakeStreamBase::CreateHelper::DataKey(),
 287                    create_helper.release());
 288   req_.SetLoadFlags(LOAD_DISABLE_CACHE);
 289   job->Start();
 290   base::RunLoop().RunUntilIdle();
 291   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_.status().status());
 292   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 293 }
 294
 295 }  // namespace
 296
 297 }  // namespace net