[chromedriver] Write websocket client and sync websocket client.

chrome/test/chromedriver/net/web_socket_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 <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/location.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/stringprintf.h"
+#include "base/time.h"
+#include "chrome/test/chromedriver/net/web_socket.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/base/tcp_listen_socket.h"
+#include "net/server/http_server.h"
+#include "net/server/http_server_request_info.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 {
+
+void OnConnectFinished(bool* save_success, bool success) {
+  MessageLoop::current()->Quit();
+  *save_success = success;
+}
+
+class Listener : public WebSocketListener {
+ public:
+  explicit Listener(const std::vector<std::string>& messages)
+      : messages_(messages) {}
+
+  virtual ~Listener() {
+    EXPECT_TRUE(messages_.empty());
+  }
+
+  virtual void OnMessageReceived(const std::string& message) OVERRIDE {
+    ASSERT_TRUE(messages_.size());
+    EXPECT_EQ(messages_[0], message);
+    messages_.erase(messages_.begin());
+    if (messages_.empty())
+      MessageLoop::current()->Quit();
+  }
+
+  virtual void OnClose() OVERRIDE {
+    EXPECT_TRUE(false);
+  }
+
+ private:
+  std::vector<std::string> messages_;
+};
+
+class CloseListener : public WebSocketListener {
+ public:
+  explicit CloseListener(bool expect_close) : expect_close_(expect_close) {}
+
+  virtual ~CloseListener() {
+    EXPECT_FALSE(expect_close_);
+  }
+
+  virtual void OnMessageReceived(const std::string& message) OVERRIDE {}
+
+  virtual void OnClose() OVERRIDE {
+    EXPECT_TRUE(expect_close_);
+    if (expect_close_)
+      MessageLoop::current()->Quit();
+    expect_close_ = false;
+  }
+
+ private:
+  bool expect_close_;
+};
+

[Takashi Toyoshima, 2012/11/27 07:57:37]

I think DevTools uses net::HttpServer and ChromeDriver will connect to this,
right?
So, this test seems good for testing real cases, but I think you should use
net::TestServer for testing client implementation.

net::TestSerevr supports WebSocket and performs strict protocol check.

What do you think about this?

[kkania, 2012/11/27 19:58:23]

Yes, DevTools uses net::HttpServer, which ChromeDriver will connect to.

I'm not sure I see the benefit of using net::TestServer, except I suppose all
the other net test code uses it. It'll probably be slower (since it starts
python), and it's not the real server I care about. Plus, is it as easy to
simulate different conditions such as returning 404 or closing the socket in the
middle of a request or message?

This WebSocket class is meant to work with net::HttpServer and is not intended
to work in all circumstances like Chrome websockets are. If for some reason this
class wants to be generalized to handle all WebSocket servers, we could migrate
to net::TestServer.

[Takashi Toyoshima, 2012/11/28 09:11:30]

I'm just afraid that DevTools and ChromeDriver use not WebSocket, but
WebSocket-like protocol. Once the tool is distributed, migration to the right
protocol will be difficult.

From the viewpoint of testing, net::TestServer has features to simulate various
situation.

But, as you said, it may be overkill for this. I agree that this test use
net::HttpServer for now. We may want to use net::TestServer when we integrate
this implementation to net/websocket/websocket_stream or something.

+class WebSocketTest : public testing::Test,
+                      public net::HttpServer::Delegate {
+ public:
+  enum WebSocketRequestResponse {
+    kAccept = 0,
+    kNotFound,
+    kClose
+  };
+
+  WebSocketTest()
+      : ALLOW_THIS_IN_INITIALIZER_LIST(server_(CreateServer())),
+        context_getter_(
+            new net::TestURLRequestContextGetter(loop_.message_loop_proxy())),
+        ws_request_response_(kAccept),
+        close_on_message_(false),
+        quit_on_close_(false) {
+    net::IPEndPoint address;
+    CHECK_EQ(net::OK, server_->GetLocalAddress(&address));
+    server_url_ = GURL(base::StringPrintf("ws://127.0.0.1:%d", address.port()));
+  }
+
+  // Overridden from net::HttpServer::Delegate:
+  virtual void OnHttpRequest(int connection_id,
+                             const net::HttpServerRequestInfo& info) {}
+
+  virtual void OnWebSocketRequest(int connection_id,
+                                  const net::HttpServerRequestInfo& info) {
+    switch (ws_request_response_) {
+      case kAccept:
+        server_->AcceptWebSocket(connection_id, info);
+        break;
+      case kNotFound:
+        server_->Send404(connection_id);
+        break;
+      case kClose:
+        // net::HttpServer doesn't allow us to close connection during callback.
+        MessageLoop::current()->PostTask(
+            FROM_HERE,
+            base::Bind(&net::HttpServer::Close, server_, connection_id));
+        break;
+    }
+  }
+
+  virtual void OnWebSocketMessage(int connection_id,
+                                  const std::string& data) {
+    if (close_on_message_) {
+      // net::HttpServer doesn't allow us to close connection during callback.
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&net::HttpServer::Close, server_, connection_id));
+    } else {
+      server_->SendOverWebSocket(connection_id, data);
+    }
+  }
+
+  virtual void OnClose(int connection_id) {
+    if (quit_on_close_)
+      MessageLoop::current()->Quit();
+  }
+
+ protected:
+  net::HttpServer* CreateServer() {
+    net::TCPListenSocketFactory factory("127.0.0.1", 0);
+    return new net::HttpServer(factory, this);
+  }
+
+  scoped_ptr<WebSocket> CreateWebSocket(const GURL& url,
+                                        WebSocketListener* listener) {
+    bool success = false;
+    scoped_ptr<WebSocket> sock(new WebSocket(
+        context_getter_, url, listener));
+    sock->Connect(base::Bind(&OnConnectFinished, &success));
+    loop_.PostDelayedTask(
+        FROM_HERE, MessageLoop::QuitWhenIdleClosure(),
+        base::TimeDelta::FromSeconds(10));
+    base::RunLoop().Run();
+    if (success)
+      return sock.Pass();
+    return scoped_ptr<WebSocket>();
+  }
+
+  scoped_ptr<WebSocket> CreateConnectedWebSocket(WebSocketListener* listener) {
+    return CreateWebSocket(server_url_, listener);
+  }
+
+  void ReadWrite(const std::vector<std::string>& messages) {
+    Listener listener(messages);
+    scoped_ptr<WebSocket> sock(CreateConnectedWebSocket(&listener));
+    ASSERT_TRUE(sock);
+    for (size_t i = 0; i < messages.size(); ++i) {
+      ASSERT_TRUE(sock->Write(messages[i]));
+    }
+    base::RunLoop run_loop;
+    loop_.PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(),
+        base::TimeDelta::FromSeconds(10));
+    run_loop.Run();
+  }
+
+  MessageLoopForIO loop_;
+  scoped_refptr<net::HttpServer> server_;
+  scoped_refptr<net::URLRequestContextGetter> context_getter_;
+  GURL server_url_;
+  WebSocketRequestResponse ws_request_response_;
+  bool close_on_message_;
+  bool quit_on_close_;
+};
+
+}  // namespace
+
+TEST_F(WebSocketTest, CreateDestroy) {
+  CloseListener listener(false);
+  WebSocket sock(context_getter_, GURL("http://ok"), &listener);
+}
+
+TEST_F(WebSocketTest, Connect) {
+  CloseListener listener(false);
+  ASSERT_TRUE(CreateWebSocket(server_url_, &listener));
+  quit_on_close_ = true;
+  base::RunLoop run_loop;
+  loop_.PostDelayedTask(
+      FROM_HERE, run_loop.QuitClosure(),
+      base::TimeDelta::FromSeconds(10));
+  run_loop.Run();
+}
+
+TEST_F(WebSocketTest, ConnectNoServer) {
+  CloseListener listener(false);
+  ASSERT_FALSE(CreateWebSocket(GURL("ws://127.0.0.1:33333"), NULL));
+}
+
+TEST_F(WebSocketTest, Connect404) {
+  ws_request_response_ = kNotFound;
+  CloseListener listener(false);
+  ASSERT_FALSE(CreateWebSocket(server_url_, NULL));
+  quit_on_close_ = true;
+  base::RunLoop run_loop;
+  loop_.PostDelayedTask(
+      FROM_HERE, run_loop.QuitClosure(),
+      base::TimeDelta::FromSeconds(10));
+  run_loop.Run();
+}
+
+TEST_F(WebSocketTest, ConnectServerClosesConn) {
+  ws_request_response_ = kClose;
+  CloseListener listener(false);
+  ASSERT_FALSE(CreateWebSocket(server_url_, &listener));
+}
+
+TEST_F(WebSocketTest, CloseOnRead) {
+  close_on_message_ = true;
+  CloseListener listener(true);
+  scoped_ptr<WebSocket> sock(CreateConnectedWebSocket(&listener));
+  ASSERT_TRUE(sock);
+  ASSERT_TRUE(sock->Write("hi"));
+  base::RunLoop run_loop;
+  loop_.PostDelayedTask(
+      FROM_HERE, run_loop.QuitClosure(),
+      base::TimeDelta::FromSeconds(10));
+  run_loop.Run();
+}
+
+TEST_F(WebSocketTest, CloseOnWrite) {
+  CloseListener listener(true);
+  scoped_ptr<WebSocket> sock(CreateConnectedWebSocket(&listener));
+  ASSERT_TRUE(sock);
+  server_ = NULL;
+  loop_.PostTask(
+      FROM_HERE,
+      base::Bind(base::IgnoreResult(&WebSocket::Write),
+                 base::Unretained(sock.get()), "hi"));
+  base::RunLoop run_loop;
+  loop_.PostDelayedTask(
+      FROM_HERE, run_loop.QuitClosure(),
+      base::TimeDelta::FromSeconds(10));
+  run_loop.Run();
+}
+
+TEST_F(WebSocketTest, ReadWrite) {
+  std::vector<std::string> messages;
+  messages.push_back("hello");
+  ReadWrite(messages);
+}
+
+TEST_F(WebSocketTest, ReadWriteLarge) {
+  std::vector<std::string> messages;
+  // Writes/reads 200kb. For some reason pushing this above 240kb on my
+  // machine results in receiving no data back from the http server.
+  messages.push_back(std::string(200 << 10, 'a'));
+  ReadWrite(messages);
+}
+
+TEST_F(WebSocketTest, ReadWriteMultiple) {
+  std::vector<std::string> messages;
+  messages.push_back("1");
+  messages.push_back("2");
+  messages.push_back("3");
+  ReadWrite(messages);
+}