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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
@@ skipping 20 matching lines @@
 #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 {
 
+int kMaxExpectedResponseLength = 2048;

[mef, 2014/03/27 15:03:45]

const

[gunsch, 2014/03/27 15:52:39]

Done.

+
 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();
   }
 
+  bool Read(std::string* data) {
+    base::RunLoop run_loop;
+    Read(run_loop.QuitClosure());
+    bool success = RunLoopWithTimeout(&run_loop);
+    std::string io_buffer_contents(read_buffer_->data());
+    *data = io_buffer_contents.substr(0, bytes_received_);
+    return success;
+  }
+
  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 Read(const base::Closure& quit_loop) {
+    read_buffer_ = new IOBufferWithSize(kMaxExpectedResponseLength);
+    int result = socket_->Read(read_buffer_, kMaxExpectedResponseLength,

[mef, 2014/03/27 15:03:45]

nit: I believe kMaxExpectedResponseLength goes on separate line.

[gunsch, 2014/03/27 15:52:39]

Done.

+                               base::Bind(&TestHttpClient::OnRead,
+                                          base::Unretained(this),
+                                          quit_loop));
+    if (result != ERR_IO_PENDING)
+      OnRead(quit_loop, result);
+  }
+
+  void OnRead(const base::Closure& quit_loop, int result) {
+    bytes_received_ = result;
+    quit_loop.Run();
+  }
+
+  base::Closure run_loop_quit_func_;

[Ryan Sleevi, 2014/03/27 20:59:46]

You shouldn't need this separate RunLoop helper. You should be able to use
TestCompletionCallback w/ WaitForResult() to handle just this.

[gunsch, 2014/03/27 23:41:17]

Done, thanks for the tip. That's a lot simpler.

+  scoped_refptr<IOBufferWithSize> read_buffer_;
   scoped_refptr<DrainableIOBuffer> write_buffer_;
   scoped_ptr<TCPClientSocket> socket_;
+  int bytes_received_;
   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);
+    connection_ids_.push_back(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 {}

[mef, 2014/03/27 15:03:45]

Should it remove the |connection_id| from |connection_ids_|?

[gunsch, 2014/03/27 15:52:39]

I lean towards _no_, to keep |requests_| and |connection_ids_| in sync. I feel
like it might be more appropriate to add a small struct for (request,
connection_id) pairs and only keep a vector of those structs. That's my
intuition coming more from Java though, would that be appropriate here as well?

 
   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;
   }
 
  protected:
   scoped_refptr<HttpServer> server_;
   IPEndPoint server_address_;
   base::Closure run_loop_quit_func_;
   std::vector<HttpServerRequestInfo> requests_;
+  std::vector<int> connection_ids_;
 
  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));
@@ skipping 79 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(connection_ids_[0], "Response!", "text/plain");
+
+  std::string response;
+  ASSERT_TRUE(client.Read(&response));
+  ASSERT_TRUE(StartsWithASCII(response, "HTTP/1.1 200 OK", true));
+  ASSERT_TRUE(response.find("Response!") != std::string::npos);
+}
+
+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(connection_ids_[0], "Raw Data ");
+  server_->SendRaw(connection_ids_[0], "More Data");
+  server_->SendRaw(connection_ids_[0], "Third Piece of Data");
+
+  std::string response;
+  ASSERT_TRUE(client.Read(&response));

[mef, 2014/03/27 15:03:45]

Would it make sense to also test a scenario where client reads are mixed with
server sends?

[gunsch, 2014/03/27 15:52:39]

Sure, I extended the MultipleRequestsOnSameConnection test to send and verify
several responses on the same connection.

[gunsch, 2014/03/27 18:40:32]

I just went ahead and made this a std::pair. I think that's clearer.

+  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:
@@ skipping 37 matching lines @@
   client.Send("GET /test2 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(2));
   ASSERT_EQ("/test2", requests_[1].path);
 
   client.Send("GET /test3 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(3));
   ASSERT_EQ("/test3", requests_[2].path);
 }
 
 }  // namespace net