Retry idempotent methods on Chrome-Proxy: bypass

net/http/http_network_layer_unittest.cc

 // Copyright (c) 2012 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_layer.h"
 
 #include "base/strings/stringprintf.h"
 #include "net/base/net_log.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
@@ skipping 36 matching lines @@
     network_session_ = new HttpNetworkSession(session_params);
     factory_.reset(new HttpNetworkLayer(network_session_.get()));
   }
 
 #if defined (SPDY_PROXY_AUTH_ORIGIN)
   std::string GetChromeProxy() {
     return HostPortPair::FromURL(GURL(SPDY_PROXY_AUTH_ORIGIN)).ToString();
   }
 #endif
 
-  void ExecuteRequestExpectingContentAndHeader(const std::string& content,
+  void ExecuteRequestExpectingContentAndHeader(const std::string& method,
+                                               const std::string& content,
                                                const std::string& header,
                                                const std::string& value) {
     TestCompletionCallback callback;
 
     HttpRequestInfo request_info;
     request_info.url = GURL("http://www.google.com/");
-    request_info.method = "GET";
+    request_info.method = method;
     request_info.load_flags = LOAD_NORMAL;
 
     scoped_ptr<HttpTransaction> trans;
     int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans, NULL);
     EXPECT_EQ(OK, rv);
 
     rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_EQ(OK, rv);
@@ skipping 32 matching lines @@
       MockRead("Bypass message"),
       MockRead(SYNCHRONOUS, OK),
     };
     TestProxyFallbackWithMockReads(bad_proxy, data_reads,
                                    arraysize(data_reads));
   }
 
   void TestProxyFallbackWithMockReads(const std::string& bad_proxy,
                                       MockRead data_reads[],
                                       int data_reads_size) {
+    TestProxyFallbackByMethodWithMockReads(bad_proxy, data_reads,
+                                           data_reads_size,
+                                           "GET", "content", true);
+
+  }
+
+  void TestProxyFallbackByMethodWithMockReads(const std::string& bad_proxy,
+                                              MockRead data_reads[],
+                                              int data_reads_size,
+                                              std::string method,
+                                              std::string content,
+                                              bool retry_expected) {
+
+    std::string trailer =
+        (method == "HEAD" || method == "PUT" || method == "POST") ?
+        "Content-Length: 0\r\n\r\n" : "\r\n";
+    std::string request =
+        base::StringPrintf("%s http://www.google.com/ HTTP/1.1\r\n"
+                           "Host: www.google.com\r\n"
+                           "Proxy-Connection: keep-alive\r\n"
+                           "%s", method.c_str(), trailer.c_str());
+
     MockWrite data_writes[] = {
-      MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
-                "Host: www.google.com\r\n"
-                "Proxy-Connection: keep-alive\r\n\r\n"),
+      MockWrite(request.c_str()),
     };
 
     StaticSocketDataProvider data1(data_reads, data_reads_size,
                                   data_writes, arraysize(data_writes));
     mock_socket_factory_.AddSocketDataProvider(&data1);
 
     // Second data provider returns the expected content.
-    MockRead data_reads2[] = {
-      MockRead("HTTP/1.0 200 OK\r\n"
-               "Server: not-proxy\r\n\r\n"),
-      MockRead("content"),
-      MockRead(SYNCHRONOUS, OK),
+    MockRead data_reads2[3];
+    size_t data_reads2_index = 0;
+    data_reads2[data_reads2_index++] = MockRead("HTTP/1.0 200 OK\r\n"
+                                                "Server: not-proxy\r\n\r\n");
+    if (!content.empty())
+      data_reads2[data_reads2_index++] = MockRead(content.c_str());
+    data_reads2[data_reads2_index++] = MockRead(SYNCHRONOUS, OK);
+
+
+    MockWrite data_writes2[] = {
+      MockWrite(request.c_str()),
     };
-    MockWrite data_writes2[] = {
-      MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
-                "Host: www.google.com\r\n"
-                "Proxy-Connection: keep-alive\r\n\r\n"),
-    };
-    StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
+    StaticSocketDataProvider data2(data_reads2, data_reads2_index,
                                   data_writes2, arraysize(data_writes2));
     mock_socket_factory_.AddSocketDataProvider(&data2);
 
     // Expect that we get "content" and not "Bypass message", and that there's
     // a "not-proxy" "Server:" header in the final response.
-    ExecuteRequestExpectingContentAndHeader("content", "server", "not-proxy");
+    if (retry_expected) {
+      ExecuteRequestExpectingContentAndHeader(method, content,
+                                              "server", "not-proxy");
+    } else {
+      ExecuteRequestExpectingContentAndHeader(method, "Bypass message", "", "");
+    }
 
     // We should also observe the bad proxy in the retry list.
     TestBadProxies(1u, bad_proxy, "");
   }
 
   // Simulates a request through a proxy which returns a bypass, which is then
   // retried through a direct connection to the origin site.
   // Checks that the expected requests were issued, the expected content was
   // received, and the proxy |bad_proxy| was marked as bad.
   void TestProxyFallbackToDirect(const std::string& bad_proxy) {
@@ skipping 23 matching lines @@
       MockWrite("GET / HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                    data_writes2, arraysize(data_writes2));
     mock_socket_factory_.AddSocketDataProvider(&data2);
 
     // Expect that we get "content" and not "Bypass message", and that there's
     // a "not-proxy" "Server:" header in the final response.
-    ExecuteRequestExpectingContentAndHeader("content", "server", "not-proxy");
+    ExecuteRequestExpectingContentAndHeader("GET", "content",
+                                            "server", "not-proxy");
 
     // We should also observe the bad proxy in the retry list.
     TestBadProxies(1u, bad_proxy, "");
   }
 
   // Simulates a request through a proxy which returns a bypass, under a
   // configuration where there is no valid bypass. |proxy_count| proxies
   // are expected to be configured.
   // Checks that the expected requests were issued, the bypass message was the
   // final received content,  and all proxies were marked as bad.
@@ skipping 14 matching lines @@
     StaticSocketDataProvider data1(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes));
     StaticSocketDataProvider data2(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes));
 
     mock_socket_factory_.AddSocketDataProvider(&data1);
     if (proxy_count > 1)
       mock_socket_factory_.AddSocketDataProvider(&data2);
 
     // Expect that we get "Bypass message", and not "content"..
-    ExecuteRequestExpectingContentAndHeader("Bypass message", "", "");
+    ExecuteRequestExpectingContentAndHeader("GET", "Bypass message", "", "");
 
     // We should also observe the bad proxy or proxies in the retry list.
     TestBadProxies(proxy_count, bad_proxy, bad_proxy2);
   }
 
   MockClientSocketFactory mock_socket_factory_;
   MockHostResolver host_resolver_;
   scoped_ptr<CertVerifier> cert_verifier_;
   scoped_ptr<TransportSecurityState> transport_security_state_;
   scoped_ptr<ProxyService> proxy_service_;
@@ skipping 88 matching lines @@
   TestProxyFallback(bad_proxy);
 }
 
 TEST_F(HttpNetworkLayerTest, ServerTwoProxyBypassFixed) {
   std::string bad_proxy = GetChromeProxy();
   ConfigureTestDependencies(
       ProxyService::CreateFixed(bad_proxy +", good:8080"));
   TestProxyFallback(bad_proxy);
 }
 
+TEST_F(HttpNetworkLayerTest, BypassAndRetryIdempotentMethods) {
+  std::string bad_proxy = GetChromeProxy();
+  const struct {
+    const char* method;

[mef, 2013/12/18 16:34:41]

why is method const char* but content std::string?

[bengr, 2013/12/18 19:39:47]

No good reason. Changed so both are std::string.

+    std::string content;
+    bool expected_to_retry;
+  } tests[] = {
+    {
+      "GET",
+      "content",
+      true,
+    },
+    {
+      "OPTIONS",
+      "content",
+      true,
+    },
+    {
+      "HEAD",
+      "",
+      true,
+    },
+    {
+      "PUT",
+      "",
+      true,
+    },
+    {
+      "DELETE",
+      "content",
+      true,
+    },
+    {
+      "TRACE",
+      "content",
+      true,
+    },
+    {
+      "POST",
+      "Bypass message",
+      false,
+    },
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    ConfigureTestDependencies(
+        ProxyService::CreateFixed(bad_proxy +", good:8080"));
+    MockRead data_reads[] = {
+      MockRead("HTTP/1.1 200 OK\r\n"
+               "Connection: proxy-bypass\r\n\r\n"),
+      MockRead("Bypass message"),
+      MockRead(SYNCHRONOUS, OK),
+    };
+    TestProxyFallbackByMethodWithMockReads(bad_proxy, data_reads,
+                                           arraysize(data_reads),
+                                           tests[i].method,
+                                           tests[i].content,
+                                           tests[i].expected_to_retry);
+  }
+}
+
 TEST_F(HttpNetworkLayerTest, ServerOneProxyWithDirectBypassPac) {
   std::string bad_proxy = GetChromeProxy();
   ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult(
       "PROXY " + bad_proxy + "; DIRECT"));
   TestProxyFallbackToDirect(bad_proxy);
 }
 
 TEST_F(HttpNetworkLayerTest, ServerOneProxyWithDirectBypassFixed) {
   std::string bad_proxy = GetChromeProxy();
   ConfigureTestDependencies(
@@ skipping 257 matching lines @@
   ASSERT_EQ(ERR_CONNECTION_RESET, callback.GetResult(rv));
 
   // If the response info is null, that means that any consumer won't
   // see the network accessed bit set.
   EXPECT_EQ(NULL, trans->GetResponseInfo());
 }
 
 }  // namespace
 
 }  // namespace net