net/websockets/websocket_handshake_handler_spdy2_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/websockets/websocket_handshake_handler.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/string_util.h"
  12 #include "googleurl/src/gurl.h"
  13 #include "net/http/http_response_headers.h"
  14 #include "net/http/http_util.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "testing/platform_test.h"
  18
  19 namespace net {
  20
  21 namespace {
  22
  23 TEST(WebSocketHandshakeHandlerSpdy2Test, RequestResponse) {
  24   WebSocketHandshakeRequestHandler request_handler;
  25
  26   static const char kHandshakeRequestMessage[] =
  27       "GET /demo HTTP/1.1\r\n"
  28       "Host: example.com\r\n"
  29       "Upgrade: websocket\r\n"
  30       "Connection: Upgrade\r\n"
  31       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
  32       "Origin: http://example.com\r\n"
  33       "Sec-WebSocket-Protocol: sample\r\n"
  34       "Sec-WebSocket-Extensions: foo\r\n"
  35       "Sec-WebSocket-Version: 13\r\n"
  36       "\r\n";
  37
  38   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
  39                                            strlen(kHandshakeRequestMessage)));
  40   EXPECT_EQ(13, request_handler.protocol_version());
  41
  42   GURL url("ws://example.com/demo");
  43   std::string challenge;
  44   SpdyHeaderBlock headers;
  45   ASSERT_TRUE(request_handler.GetRequestHeaderBlock(url,
  46                                                     &headers,
  47                                                     &challenge,
  48                                                     2));
  49
  50   EXPECT_EQ(url.path(), headers["path"]);
  51   EXPECT_TRUE(headers.find("upgrade") == headers.end());
  52   EXPECT_TRUE(headers.find("Upgrade") == headers.end());
  53   EXPECT_TRUE(headers.find("connection") == headers.end());
  54   EXPECT_TRUE(headers.find("Connection") == headers.end());
  55   EXPECT_TRUE(headers.find("Sec-WebSocket-Key") == headers.end());
  56   EXPECT_TRUE(headers.find("sec-websocket-key") == headers.end());
  57   EXPECT_TRUE(headers.find("Sec-WebSocket-Version") == headers.end());
  58   EXPECT_TRUE(headers.find("sec-webSocket-version") == headers.end());
  59   EXPECT_EQ("example.com", headers["host"]);
  60   EXPECT_EQ("http://example.com", headers["origin"]);
  61   EXPECT_EQ("sample", headers["sec-websocket-protocol"]);
  62   EXPECT_EQ("foo", headers["sec-websocket-extensions"]);
  63   EXPECT_EQ("ws", headers["scheme"]);
  64   EXPECT_EQ("WebSocket/13", headers["version"]);
  65
  66   static const char expected_challenge[] = "dGhlIHNhbXBsZSBub25jZQ==";
  67
  68   EXPECT_EQ(expected_challenge, challenge);
  69
  70   headers.clear();
  71
  72   headers["status"] = "101 Switching Protocols";
  73   headers["sec-websocket-protocol"] = "sample";
  74   headers["sec-websocket-extensions"] = "foo";
  75
  76   WebSocketHandshakeResponseHandler response_handler;
  77   response_handler.set_protocol_version(13);
  78   EXPECT_TRUE(response_handler.ParseResponseHeaderBlock(headers,
  79                                                         challenge,
  80                                                         2));
  81   EXPECT_TRUE(response_handler.HasResponse());
  82
  83   // Note that order of sec-websocket-* is sensitive with hash_map order.
  84   static const char kHandshakeResponseExpectedMessage[] =
  85       "HTTP/1.1 101 Switching Protocols\r\n"
  86       "Upgrade: websocket\r\n"
  87       "Connection: Upgrade\r\n"
  88       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
  89       "sec-websocket-extensions: foo\r\n"
  90       "sec-websocket-protocol: sample\r\n"
  91       "\r\n";
  92
  93   EXPECT_EQ(kHandshakeResponseExpectedMessage, response_handler.GetResponse());
  94 }
  95
  96 TEST(WebSocketHandshakeHandlerSpdy2Test, RequestResponseWithCookies) {
  97   WebSocketHandshakeRequestHandler request_handler;
  98
  99   // Note that websocket won't use multiple headers in request now.
 100   static const char kHandshakeRequestMessage[] =
 101       "GET /demo HTTP/1.1\r\n"
 102       "Host: example.com\r\n"
 103       "Upgrade: websocket\r\n"
 104       "Connection: Upgrade\r\n"
 105       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
 106       "Origin: http://example.com\r\n"
 107       "Sec-WebSocket-Protocol: sample\r\n"
 108       "Sec-WebSocket-Extensions: foo\r\n"
 109       "Sec-WebSocket-Version: 13\r\n"
 110       "Cookie: WK-websocket-test=1; WK-websocket-test-httponly=1\r\n"
 111       "\r\n";
 112
 113   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
 114                                            strlen(kHandshakeRequestMessage)));
 115   EXPECT_EQ(13, request_handler.protocol_version());
 116
 117   GURL url("ws://example.com/demo");
 118   std::string challenge;
 119   SpdyHeaderBlock headers;
 120   ASSERT_TRUE(request_handler.GetRequestHeaderBlock(url,
 121                                                     &headers,
 122                                                     &challenge,
 123                                                     2));
 124
 125   EXPECT_EQ(url.path(), headers["path"]);
 126   EXPECT_TRUE(headers.find("upgrade") == headers.end());
 127   EXPECT_TRUE(headers.find("Upgrade") == headers.end());
 128   EXPECT_TRUE(headers.find("connection") == headers.end());
 129   EXPECT_TRUE(headers.find("Connection") == headers.end());
 130   EXPECT_TRUE(headers.find("Sec-WebSocket-Key") == headers.end());
 131   EXPECT_TRUE(headers.find("sec-websocket-key") == headers.end());
 132   EXPECT_TRUE(headers.find("Sec-WebSocket-Version") == headers.end());
 133   EXPECT_TRUE(headers.find("sec-webSocket-version") == headers.end());
 134   EXPECT_EQ("example.com", headers["host"]);
 135   EXPECT_EQ("http://example.com", headers["origin"]);
 136   EXPECT_EQ("sample", headers["sec-websocket-protocol"]);
 137   EXPECT_EQ("foo", headers["sec-websocket-extensions"]);
 138   EXPECT_EQ("ws", headers["scheme"]);
 139   EXPECT_EQ("WebSocket/13", headers["version"]);
 140   EXPECT_EQ("WK-websocket-test=1; WK-websocket-test-httponly=1",
 141             headers["cookie"]);
 142
 143   const char expected_challenge[] = "dGhlIHNhbXBsZSBub25jZQ==";
 144
 145   EXPECT_EQ(expected_challenge, challenge);
 146
 147   headers.clear();
 148
 149   headers["status"] = "101 Switching Protocols";
 150   headers["sec-websocket-protocol"] = "sample";
 151   headers["sec-websocket-extensions"] = "foo";
 152   std::string cookie = "WK-websocket-test=1";
 153   cookie.append(1, '\0');
 154   cookie += "WK-websocket-test-httponly=1; HttpOnly";
 155   headers["set-cookie"] = cookie;
 156
 157
 158   WebSocketHandshakeResponseHandler response_handler;
 159   response_handler.set_protocol_version(13);
 160   EXPECT_TRUE(response_handler.ParseResponseHeaderBlock(headers,
 161                                                         challenge,
 162                                                         2));
 163   EXPECT_TRUE(response_handler.HasResponse());
 164
 165   // Note that order of sec-websocket-* is sensitive with hash_map order.
 166   static const char kHandshakeResponseExpectedMessage[] =
 167       "HTTP/1.1 101 Switching Protocols\r\n"
 168       "Upgrade: websocket\r\n"
 169       "Connection: Upgrade\r\n"
 170       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
 171       "sec-websocket-extensions: foo\r\n"
 172       "sec-websocket-protocol: sample\r\n"
 173       "set-cookie: WK-websocket-test=1\r\n"
 174       "set-cookie: WK-websocket-test-httponly=1; HttpOnly\r\n"
 175       "\r\n";
 176
 177   EXPECT_EQ(kHandshakeResponseExpectedMessage, response_handler.GetResponse());
 178 }
 179
 180 }  // namespace
 181
 182 }  // namespace net