[net/http auth] Generalize HttpAuthHandlerMock.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 10216 matching lines @@
       "Host: www.example.com\r\n"
       "Connection: keep-alive\r\n\r\n");
   const MockWrite kGetProxy(
       "GET http://www.example.com/ HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Proxy-Connection: keep-alive\r\n\r\n");
   const MockWrite kGetAuth(
       "GET / HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Connection: keep-alive\r\n"
-      "Authorization: auth_token\r\n\r\n");
+      "Authorization: mock auth_token,realm=server\r\n\r\n");
   const MockWrite kGetProxyAuth(
       "GET http://www.example.com/ HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Proxy-Connection: keep-alive\r\n"
-      "Proxy-Authorization: auth_token\r\n\r\n");
+      "Proxy-Authorization: mock auth_token,realm=proxy\r\n\r\n");
   const MockWrite kGetAuthThroughProxy(
       "GET http://www.example.com/ HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Proxy-Connection: keep-alive\r\n"
-      "Authorization: auth_token\r\n\r\n");
+      "Authorization: mock auth_token,realm=server\r\n\r\n");
   const MockWrite kGetAuthWithProxyAuth(
       "GET http://www.example.com/ HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Proxy-Connection: keep-alive\r\n"
-      "Proxy-Authorization: auth_token\r\n"
-      "Authorization: auth_token\r\n\r\n");
+      "Proxy-Authorization: mock auth_token,realm=proxy\r\n"
+      "Authorization: mock auth_token,realm=server\r\n\r\n");
   const MockWrite kConnect(
       "CONNECT www.example.com:443 HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Proxy-Connection: keep-alive\r\n\r\n");
   const MockWrite kConnectProxyAuth(
       "CONNECT www.example.com:443 HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Proxy-Connection: keep-alive\r\n"
-      "Proxy-Authorization: auth_token\r\n\r\n");
+      "Proxy-Authorization: mock auth_token,realm=proxy\r\n\r\n");
 
   const MockRead kSuccess(
       "HTTP/1.1 200 OK\r\n"
       "Content-Type: text/html; charset=iso-8859-1\r\n"
       "Content-Length: 3\r\n\r\n"
       "Yes");
   const MockRead kFailure(
       "Should not be called.");
   const MockRead kServerChallenge(
       "HTTP/1.1 401 Unauthorized\r\n"
@@ skipping 218 matching lines @@
                   &kGet, &kServerChallenge),
         TestRound(kGetAuth, kSuccess, OK)}},
     { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_ASYNC, kAuthErr, 3, 1,
       { TestRound(kConnect, kProxyChallenge, OK),
         TestRound(kConnectProxyAuth, kProxyConnected, OK,
                   &kGet, &kServerChallenge),
         TestRound(kGetAuth, kFailure, kAuthErr)}},
   };
 
   for (size_t i = 0; i < arraysize(test_configs); ++i) {
+    SCOPED_TRACE(::testing::Message() << "Test config " << i);
     HttpAuthHandlerMock::Factory* auth_factory(
         new HttpAuthHandlerMock::Factory());
     session_deps_.http_auth_handler_factory.reset(auth_factory);
     const TestConfig& test_config = test_configs[i];
 
     // Set up authentication handlers as necessary.
     if (test_config.proxy_auth_timing != AUTH_NONE) {
       for (int n = 0; n < 2; n++) {
-        HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
-        std::string auth_challenge = "Mock realm=proxy";
-        GURL origin(test_config.proxy_url);
-        HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(),
-                                             auth_challenge.end());
-        auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_PROXY,
-                                        origin, BoundNetLog());
+        scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
         auth_handler->SetGenerateExpectation(
             test_config.proxy_auth_timing == AUTH_ASYNC,
             test_config.proxy_auth_rv);
-        auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
+        auth_factory->AddMockHandler(
+            auth_handler.Pass(),
+            n == 0 ? HttpAuthHandlerFactory::CREATE_CHALLENGE
+                   : HttpAuthHandlerFactory::CREATE_PREEMPTIVE,
+            HttpAuth::AUTH_PROXY);
       }
     }
     if (test_config.server_auth_timing != AUTH_NONE) {
-      HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
-      std::string auth_challenge = "Mock realm=server";
-      GURL origin(test_config.server_url);
-      HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(),
-                                           auth_challenge.end());
-      auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER,
-                                      origin, BoundNetLog());
+      scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
       auth_handler->SetGenerateExpectation(
           test_config.server_auth_timing == AUTH_ASYNC,
           test_config.server_auth_rv);
-      auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER);
+      auth_factory->AddMockHandler(auth_handler.Pass(),
+                                   HttpAuthHandlerFactory::CREATE_CHALLENGE,
+                                   HttpAuth::AUTH_SERVER);
     }
     if (test_config.proxy_url) {
       session_deps_.proxy_service =
           ProxyService::CreateFixed(test_config.proxy_url);
     } else {
       session_deps_.proxy_service = ProxyService::CreateDirect();
     }
 
     HttpRequestInfo request;
     request.method = "GET";
@@ skipping 38 matching lines @@
     ScopedVector<StaticSocketDataProvider> data_providers;
     for (size_t i = 0; i < mock_reads.size(); ++i) {
       data_providers.push_back(new StaticSocketDataProvider(
           vector_as_array(&mock_reads[i]), mock_reads[i].size(),
           vector_as_array(&mock_writes[i]), mock_writes[i].size()));
       session_deps_.socket_factory->AddSocketDataProvider(
           data_providers.back());
     }
 
     for (int round = 0; round < test_config.num_auth_rounds; ++round) {
+      SCOPED_TRACE(::testing::Message() << "Test round " << round);
       const TestRound& read_write_round = test_config.rounds[round];
       // Start or restart the transaction.
       TestCompletionCallback callback;
       int rv;
       if (round == 0) {
         rv = trans.Start(&request, callback.callback(), BoundNetLog());
       } else {
         rv = trans.RestartWithAuth(
             AuthCredentials(kFoo, kBar), callback.callback());
       }
@@ skipping 18 matching lines @@
 
 TEST_P(HttpNetworkTransactionTest, MultiRoundAuth) {
   // Do multi-round authentication and make sure it works correctly.
   HttpAuthHandlerMock::Factory* auth_factory(
       new HttpAuthHandlerMock::Factory());
   session_deps_.http_auth_handler_factory.reset(auth_factory);
   session_deps_.proxy_service = ProxyService::CreateDirect();
   session_deps_.host_resolver->rules()->AddRule("www.example.com", "10.0.0.1");
   session_deps_.host_resolver->set_synchronous_mode(true);
 
-  HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
+  scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
+  auth_handler->SetGenerateExpectation(false, OK);
   auth_handler->set_expect_multiple_challenges(true);
-  std::string auth_challenge = "Mock realm=server";
+  auth_factory->AddMockHandler(auth_handler.Pass(),
+                               HttpAuthHandlerFactory::CREATE_CHALLENGE,
+                               HttpAuth::AUTH_SERVER);
+
   GURL origin("http://www.example.com");
-  HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(),
-                                       auth_challenge.end());
-  auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER,
-                                  origin, BoundNetLog());
-  auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER);
-
   int rv = OK;
   const HttpResponseInfo* response = NULL;
   HttpRequestInfo request;
   request.method = "GET";
   request.url = origin;
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Use a TCP Socket Pool with only one connection per group. This is used
   // to validate that the TCP socket is not released to the pool between
   // each round of multi-round authentication.
   HttpNetworkSessionPeer session_peer(session);
   TransportClientSocketPool* transport_pool = new TransportClientSocketPool(
       50,  // Max sockets for pool
       1,   // Max sockets per group
       session_deps_.host_resolver.get(),
       session_deps_.socket_factory.get(),
       session_deps_.net_log);
   scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
       new MockClientSocketPoolManager);
   mock_pool_manager->SetTransportSocketPool(transport_pool);
   session_peer.SetClientSocketPoolManager(mock_pool_manager.Pass());
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
+  // Initial request
   const MockWrite kGet(
       "GET / HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Connection: keep-alive\r\n\r\n");
-  const MockWrite kGetAuth(
-      "GET / HTTP/1.1\r\n"
-      "Host: www.example.com\r\n"
-      "Connection: keep-alive\r\n"
-      "Authorization: auth_token\r\n\r\n");
 
+  // Challenge / Response cycle. Repeats 3 times for primary request. Competing
+  // request never sees the server challenge.
   const MockRead kServerChallenge(
       "HTTP/1.1 401 Unauthorized\r\n"
       "WWW-Authenticate: Mock realm=server\r\n"
       "Content-Type: text/html; charset=iso-8859-1\r\n"
       "Content-Length: 14\r\n\r\n"
       "Unauthorized\r\n");
+  const MockWrite kGetAuth(
+      "GET / HTTP/1.1\r\n"
+      "Host: www.example.com\r\n"
+      "Connection: keep-alive\r\n"
+      "Authorization: mock auth_token,realm=server\r\n\r\n");
+  const MockWrite kGetAuthContinuation(
+      "GET / HTTP/1.1\r\n"
+      "Host: www.example.com\r\n"
+      "Connection: keep-alive\r\n"
+      "Authorization: mock continuation,realm=server\r\n\r\n");
+
+  // Final server response.
   const MockRead kSuccess(
       "HTTP/1.1 200 OK\r\n"
       "Content-Type: text/html; charset=iso-8859-1\r\n"
       "Content-Length: 3\r\n\r\n"
       "Yes");
 
   MockWrite writes[] = {
-    // First round
-    kGet,
-    // Second round
-    kGetAuth,
-    // Third round
-    kGetAuth,
-    // Fourth round
-    kGetAuth,
-    // Competing request
-    kGet,
+      // First round
+      kGet,
+      // Second round
+      kGetAuth,
+      // Third round
+      kGetAuthContinuation,
+      // Fourth round
+      kGetAuthContinuation,
+      // Competing request
+      kGet,
   };
   MockRead reads[] = {
     // First round
     kServerChallenge,
     // Second round
     kServerChallenge,
     // Third round
     kServerChallenge,
     // Fourth round
     kSuccess,
     // Competing response
     kSuccess,
   };
   StaticSocketDataProvider data_provider(reads, arraysize(reads),
                                          writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data_provider);
 
   const char kSocketGroup[] = "www.example.com:80";
 
   // First round of authentication.
-  auth_handler->SetGenerateExpectation(false, OK);
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL);
-  EXPECT_FALSE(response->auth_challenge.get() == NULL);
+  ASSERT_TRUE(response);
+  EXPECT_TRUE(response->auth_challenge.get());
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // In between rounds, another request comes in for the same domain.
   // It should not be able to grab the TCP socket that trans has already
   // claimed.
   scoped_ptr<HttpTransaction> trans_compete(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback_compete;
   rv = trans_compete->Start(
       &request, callback_compete.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // callback_compete.WaitForResult at this point would stall forever,
   // since the HttpNetworkTransaction does not release the request back to
   // the pool until after authentication completes.
 
   // Second round of authentication.
-  auth_handler->SetGenerateExpectation(false, OK);
   rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), callback.callback());
-  if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_EQ(OK, callback.GetResult(rv));
   response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->auth_challenge.get() == NULL);
+  ASSERT_TRUE(response);
+  EXPECT_FALSE(response->auth_challenge.get());
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // Third round of authentication.
-  auth_handler->SetGenerateExpectation(false, OK);
   rv = trans->RestartWithAuth(AuthCredentials(), callback.callback());
-  if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_EQ(OK, callback.GetResult(rv));
   response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->auth_challenge.get() == NULL);
+  ASSERT_TRUE(response);
+  EXPECT_FALSE(response->auth_challenge.get());
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // Fourth round of authentication, which completes successfully.
-  auth_handler->SetGenerateExpectation(false, OK);
   rv = trans->RestartWithAuth(AuthCredentials(), callback.callback());
-  if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_EQ(OK, callback.GetResult(rv));
   response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->auth_challenge.get() == NULL);
+  ASSERT_TRUE(response);
+  EXPECT_FALSE(response->auth_challenge.get());
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // Read the body since the fourth round was successful. This will also
   // release the socket back to the pool.
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(50));
   rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
-  if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
-  EXPECT_EQ(3, rv);
+  EXPECT_EQ(3, callback.GetResult(rv));
   rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
   // There are still 0 idle sockets, since the trans_compete transaction
   // will be handed it immediately after trans releases it to the group.
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
   // The competing request can now finish. Wait for the headers and then
   // read the body.
   rv = callback_compete.WaitForResult();
   EXPECT_EQ(OK, rv);
   rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
-  if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
-  EXPECT_EQ(3, rv);
+  EXPECT_EQ(3, callback.GetResult(rv));
   rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
   EXPECT_EQ(1, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 }
 
 // This tests the case that a request is issued via http instead of spdy after
 // npn is negotiated.
 TEST_P(HttpNetworkTransactionTest, NpnWithHttpOverSSL) {
@@ skipping 127 matching lines @@
   session_deps_.next_protos = SpdyNextProtos();
 
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
   TestNetLog net_log;
   session_deps_.net_log = &net_log;
   GURL request_url;
   {
     HttpAuthHandlerMock::Factory* auth_factory =
         new HttpAuthHandlerMock::Factory();
-    UrlRecordingHttpAuthHandlerMock* auth_handler =
-        new UrlRecordingHttpAuthHandlerMock(&request_url);
-    auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
-    auth_factory->set_do_init_from_challenge(true);
+    scoped_ptr<UrlRecordingHttpAuthHandlerMock> auth_handler(
+        new UrlRecordingHttpAuthHandlerMock(&request_url));
+    auth_factory->AddMockHandler(auth_handler.Pass(),
+                                 HttpAuthHandlerFactory::CREATE_CHALLENGE,
+                                 HttpAuth::AUTH_PROXY);
     session_deps_.http_auth_handler_factory.reset(auth_factory);
   }
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org");
   request.load_flags = 0;
 
   // First round goes unauthenticated through the proxy.
   MockWrite data_writes_1[] = {
@@ skipping 43 matching lines @@
                 "CONNECT www.example.org:443 HTTP/1.1\r\n"
                 "Host: www.example.org\r\n"
                 "Proxy-Connection: keep-alive\r\n"
                 "\r\n"),
 
       // Second connection attempt with Proxy-Authorization.
       MockWrite(ASYNC, 2,
                 "CONNECT www.example.org:443 HTTP/1.1\r\n"
                 "Host: www.example.org\r\n"
                 "Proxy-Connection: keep-alive\r\n"
-                "Proxy-Authorization: auth_token\r\n"
+                "Proxy-Authorization: mock auth_token\r\n"
                 "\r\n"),
 
       // SPDY request
       CreateMockWrite(*req, 4),
   };
   const char kRejectConnectResponse[] = ("HTTP/1.1 407 Unauthorized\r\n"
                                          "Proxy-Authenticate: Mock\r\n"
                                          "Proxy-Connection: close\r\n"
                                          "\r\n");
   const char kAcceptConnectResponse[] = "HTTP/1.1 200 Connected\r\n\r\n";
@@ skipping 3748 matching lines @@
   std::string response_data;
   EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data));
 
   EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
             trans->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
             trans->GetTotalReceivedBytes());
 }
 
 }  // namespace net