HttpServer: allows sending raw response data for nontypical responses.

net/server/http_server_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 <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
+#include "net/base/test_completion_callback.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_listen_socket.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
+const int kMaxExpectedResponseLength = 2048;
+
 void SetTimedOutAndQuitLoop(const base::WeakPtr<bool> timed_out,
                             const base::Closure& quit_loop_func) {
   if (timed_out) {
     *timed_out = true;
     quit_loop_func.Run();
   }
 }
 
 bool RunLoopWithTimeout(base::RunLoop* run_loop) {
   bool timed_out = false;
@@ skipping 28 matching lines @@
       return ERR_TIMED_OUT;
     return connect_result_;
   }
 
   void Send(const std::string& data) {
     write_buffer_ =
         new DrainableIOBuffer(new StringIOBuffer(data), data.length());
     Write();
   }
 
+  const std::string Read() {
+    net::TestCompletionCallback callback;
+    ReadInternal(callback.callback());
+    int bytes_received = callback.WaitForResult();
+    EXPECT_GT(bytes_received, 0);

[Ryan Sleevi, 2014/04/10 20:58:36]

This won't do what you want.

When this condition fails, the test will fail, yes, but it will continue
executing. When it gets to line 99, it's going to request a substr(0,
-some-negative-number), which won't do what you want.

Handle this here (eg: if (bytes_received < 0) return std::string()), it seems,
and EXPECT_()/ASSERT_() in the calling function?

[gunsch, 2014/04/11 16:55:57]

Interesting, guess I was still expecting the Java/JUnit style of "drop an assert
anywhere and the test exits if it fails." Updated.

+    std::string io_buffer_contents(read_buffer_->data());
+    return io_buffer_contents.substr(0, bytes_received);
+  }
+
  private:
   void OnConnect(const base::Closure& quit_loop, int result) {
     connect_result_ = result;
     quit_loop.Run();
   }
 
   void Write() {
     int result = socket_->Write(
         write_buffer_.get(),
         write_buffer_->BytesRemaining(),
         base::Bind(&TestHttpClient::OnWrite, base::Unretained(this)));
     if (result != ERR_IO_PENDING)
       OnWrite(result);
   }
 
   void OnWrite(int result) {
     ASSERT_GT(result, 0);
     write_buffer_->DidConsume(result);
     if (write_buffer_->BytesRemaining())
       Write();
   }
 
+  void ReadInternal(const net::CompletionCallback& callback) {
+    read_buffer_ = new IOBufferWithSize(kMaxExpectedResponseLength);
+    int result = socket_->Read(read_buffer_,
+                               kMaxExpectedResponseLength,
+                               callback);
+    if (result != ERR_IO_PENDING)
+      callback.Run(result);
+  }
+
+  scoped_refptr<IOBufferWithSize> read_buffer_;
   scoped_refptr<DrainableIOBuffer> write_buffer_;
   scoped_ptr<TCPClientSocket> socket_;
   int connect_result_;
 };
 
 }  // namespace
 
 class HttpServerTest : public testing::Test,
                        public HttpServer::Delegate {
  public:
   HttpServerTest() : quit_after_request_count_(0) {}
 
   virtual void SetUp() OVERRIDE {
     TCPListenSocketFactory socket_factory("127.0.0.1", 0);
     server_ = new HttpServer(socket_factory, this);
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
   virtual void OnHttpRequest(int connection_id,
                              const HttpServerRequestInfo& info) OVERRIDE {
-    requests_.push_back(info);
+    requests_.push_back(std::make_pair(info, connection_id));
     if (requests_.size() == quit_after_request_count_)
       run_loop_quit_func_.Run();
   }
 
   virtual void OnWebSocketRequest(int connection_id,
                                   const HttpServerRequestInfo& info) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void OnWebSocketMessage(int connection_id,
                                   const std::string& data) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void OnClose(int connection_id) OVERRIDE {}
 
   bool RunUntilRequestsReceived(size_t count) {
     quit_after_request_count_ = count;
     if (requests_.size() == count)
       return true;
 
     base::RunLoop run_loop;
     run_loop_quit_func_ = run_loop.QuitClosure();
     bool success = RunLoopWithTimeout(&run_loop);
     run_loop_quit_func_.Reset();
     return success;
   }
 
+  HttpServerRequestInfo GetRequest(size_t request_index) {
+    EXPECT_LE(request_index, requests_.size());

[Ryan Sleevi, 2014/04/10 20:58:36]

This doesn't really do what you want, for similar reasons as above. When you hit
line 185, you're going to crash the test if request_index > requests_.size()

Better to handle it here, or move this check into the calling function?

(Note: Don't replace these with DCHECK() - it would have the same effect for
test flakiness, as it would crash the test)

Normally you'd use ASSERT_LE(), but that requires a void return, and will only
terminate the test if it's in the test body (otherwise it would just "return")

see
https://code.google.com/p/googletest/wiki/AdvancedGuide#Propagating_Fatal_Fai...
to understand the patterns

[gunsch, 2014/04/11 16:55:57]

In that case, I'd rather remove these checks----it's a simple array index, and
the calling tests are already asserting that N requests were successfully made
(ASSERT_TRUE(RunUntilRequestsReceived)). I don't think propagating a success
boolean adds anything to the test for the extra complexity.

Thanks for the link though, that helps with the test paradigms generally.

+    return requests_[request_index].first;
+  }
+
+  int GetConnectionId(size_t request_index) {
+    EXPECT_LE(request_index, requests_.size());

[Ryan Sleevi, 2014/04/10 20:58:36]

Ditto; this doesn't do what you expect.

[gunsch, 2014/04/11 16:55:57]

Done.

+    return requests_[request_index].second;
+  }
+
  protected:
   scoped_refptr<HttpServer> server_;
   IPEndPoint server_address_;
   base::Closure run_loop_quit_func_;
-  std::vector<HttpServerRequestInfo> requests_;
+  std::vector<std::pair<HttpServerRequestInfo, int> > requests_;
 
  private:
   size_t quit_after_request_count_;
 };
 
 TEST_F(HttpServerTest, Request) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
-  ASSERT_EQ("GET", requests_[0].method);
-  ASSERT_EQ("/test", requests_[0].path);
-  ASSERT_EQ("", requests_[0].data);
-  ASSERT_EQ(0u, requests_[0].headers.size());
-  ASSERT_TRUE(StartsWithASCII(requests_[0].peer.ToString(), "127.0.0.1", true));
+  ASSERT_EQ("GET", GetRequest(0).method);
+  ASSERT_EQ("/test", GetRequest(0).path);
+  ASSERT_EQ("", GetRequest(0).data);
+  ASSERT_EQ(0u, GetRequest(0).headers.size());
+  ASSERT_TRUE(StartsWithASCII(GetRequest(0).peer.ToString(),
+                              "127.0.0.1",
+                              true));
 }
 
 TEST_F(HttpServerTest, RequestWithHeaders) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   const char* kHeaders[][3] = {
       {"Header", ": ", "1"},
       {"HeaderWithNoWhitespace", ":", "1"},
       {"HeaderWithWhitespace", "   :  \t   ", "1 1 1 \t  "},
       {"HeaderWithColon", ": ", "1:1"},
       {"EmptyHeader", ":", ""},
       {"EmptyHeaderWithWhitespace", ":  \t  ", ""},
       {"HeaderWithNonASCII", ":  ", "\xf7"},
   };
   std::string headers;
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
     headers +=
         std::string(kHeaders[i][0]) + kHeaders[i][1] + kHeaders[i][2] + "\r\n";
   }
 
   client.Send("GET /test HTTP/1.1\r\n" + headers + "\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
-  ASSERT_EQ("", requests_[0].data);
+  ASSERT_EQ("", GetRequest(0).data);
 
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
     std::string field = StringToLowerASCII(std::string(kHeaders[i][0]));
     std::string value = kHeaders[i][2];
-    ASSERT_EQ(1u, requests_[0].headers.count(field)) << field;
-    ASSERT_EQ(value, requests_[0].headers[field]) << kHeaders[i][0];
+    ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
+    ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
   }
 }
 
 TEST_F(HttpServerTest, RequestWithBody) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   std::string body = "a" + std::string(1 << 10, 'b') + "c";
   client.Send(base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "SomeHeader: 1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str()));
   ASSERT_TRUE(RunUntilRequestsReceived(1));
-  ASSERT_EQ(2u, requests_[0].headers.size());
-  ASSERT_EQ(body.length(), requests_[0].data.length());
+  ASSERT_EQ(2u, GetRequest(0).headers.size());
+  ASSERT_EQ(body.length(), GetRequest(0).data.length());
   ASSERT_EQ('a', body[0]);
   ASSERT_EQ('c', *body.rbegin());
 }
 
 TEST_F(HttpServerTest, RequestWithTooLargeBody) {
   class TestURLFetcherDelegate : public URLFetcherDelegate {
    public:
     TestURLFetcherDelegate(const base::Closure& quit_loop_func)
         : quit_loop_func_(quit_loop_func) {}
     virtual ~TestURLFetcherDelegate() {}
@@ skipping 19 matching lines @@
                          &delegate));
   fetcher->SetRequestContext(request_context_getter.get());
   fetcher->AddExtraRequestHeader(
       base::StringPrintf("content-length:%d", 1 << 30));
   fetcher->Start();
 
   ASSERT_TRUE(RunLoopWithTimeout(&run_loop));
   ASSERT_EQ(0u, requests_.size());
 }
 
+TEST_F(HttpServerTest, Send200) {
+  TestHttpClient client;
+  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  client.Send("GET /test HTTP/1.1\r\n\r\n");
+  ASSERT_TRUE(RunUntilRequestsReceived(1));
+  server_->Send200(GetConnectionId(0), "Response!", "text/plain");
+
+  std::string response = client.Read();
+  ASSERT_TRUE(StartsWithASCII(response, "HTTP/1.1 200 OK", true));
+  ASSERT_TRUE(EndsWith(response, "Response!", true));
+}
+
+TEST_F(HttpServerTest, SendRaw) {
+  TestHttpClient client;
+  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  client.Send("GET /test HTTP/1.1\r\n\r\n");
+  ASSERT_TRUE(RunUntilRequestsReceived(1));
+  server_->SendRaw(GetConnectionId(0), "Raw Data ");
+  server_->SendRaw(GetConnectionId(0), "More Data");
+  server_->SendRaw(GetConnectionId(0), "Third Piece of Data");
+
+  std::string response = client.Read();
+  ASSERT_EQ("Raw Data More DataThird Piece of Data", response);
+}
+
 namespace {
 
 class MockStreamListenSocket : public StreamListenSocket {
  public:
   MockStreamListenSocket(StreamListenSocket::Delegate* delegate)
       : StreamListenSocket(kInvalidSocket, delegate) {}
 
   virtual void Accept() OVERRIDE { NOTREACHED(); }
 
  private:
   virtual ~MockStreamListenSocket() {}
 };
 
 }  // namespace
 
 TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
   StreamListenSocket* socket =
       new MockStreamListenSocket(server_.get());
   server_->DidAccept(NULL, make_scoped_ptr(socket));
   std::string body("body");
-  std::string request = base::StringPrintf(
+  std::string request_text = base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "SomeHeader: 1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str());
-  server_->DidRead(socket, request.c_str(), request.length() - 2);
+  server_->DidRead(socket, request_text.c_str(), request_text.length() - 2);
   ASSERT_EQ(0u, requests_.size());
-  server_->DidRead(socket, request.c_str() + request.length() - 2, 2);
+  server_->DidRead(socket, request_text.c_str() + request_text.length() - 2, 2);
   ASSERT_EQ(1u, requests_.size());
-  ASSERT_EQ(body, requests_[0].data);
+  ASSERT_EQ(body, GetRequest(0).data);
 }
 
 TEST_F(HttpServerTest, MultipleRequestsOnSameConnection) {
   // The idea behind this test is that requests with or without bodies should
   // not break parsing of the next request.
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   std::string body = "body";
   client.Send(base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str()));
   ASSERT_TRUE(RunUntilRequestsReceived(1));
-  ASSERT_EQ(body, requests_[0].data);
+  ASSERT_EQ(body, GetRequest(0).data);
+
+  int client_connection_id = GetConnectionId(0);
+  server_->Send200(client_connection_id, "Content for /test", "text/plain");
+  std::string response1 = client.Read();
+  ASSERT_TRUE(StartsWithASCII(response1, "HTTP/1.1 200 OK", true));
+  ASSERT_TRUE(EndsWith(response1, "Content for /test", true));
 
   client.Send("GET /test2 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(2));
-  ASSERT_EQ("/test2", requests_[1].path);
+  ASSERT_EQ("/test2", GetRequest(1).path);
+
+  ASSERT_EQ(client_connection_id, GetConnectionId(1));
+  server_->Send404(client_connection_id);
+  std::string response2 = client.Read();
+  ASSERT_TRUE(StartsWithASCII(response2, "HTTP/1.1 404 Not Found", true));
 
   client.Send("GET /test3 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(3));
-  ASSERT_EQ("/test3", requests_[2].path);
+  ASSERT_EQ("/test3", GetRequest(2).path);
+
+  ASSERT_EQ(client_connection_id, GetConnectionId(2));
+  server_->Send200(client_connection_id, "Content for /test3", "text/plain");
+  std::string response3 = client.Read();
+  ASSERT_TRUE(StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
+  ASSERT_TRUE(EndsWith(response3, "Content for /test3", true));
 }
 
 }  // namespace net