src/third_party/WebKit/Source/modules/websockets/DOMWebSocketTest.cpp

   1 // Copyright 2014 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 "config.h"
   6
   7 #include "modules/websockets/DOMWebSocket.h"
   8
   9 #include "bindings/core/v8/ExceptionState.h"
  10 #include "bindings/core/v8/V8Binding.h"
  11 #include "core/dom/Document.h"
  12 #include "core/dom/ExceptionCode.h"
  13 #include "core/fileapi/Blob.h"
  14 #include "core/frame/ConsoleTypes.h"
  15 #include "core/testing/DummyPageHolder.h"
  16 #include "wtf/ArrayBuffer.h"
  17 #include "wtf/OwnPtr.h"
  18 #include "wtf/Uint8Array.h"
  19 #include "wtf/Vector.h"
  20 #include "wtf/testing/WTFTestHelpers.h"
  21 #include "wtf/text/WTFString.h"
  22 #include <gmock/gmock.h>
  23 #include <gtest/gtest.h>
  24 #include <v8.h>
  25
  26 using testing::_;
  27 using testing::AnyNumber;
  28 using testing::InSequence;
  29 using testing::Ref;
  30 using testing::Return;
  31
  32 namespace blink {
  33
  34 namespace {
  35
  36 typedef testing::StrictMock<testing::MockFunction<void(int)> > Checkpoint;  // NOLINT
  37
  38 class MockWebSocketChannel : public WebSocketChannel {
  39 public:
  40     static MockWebSocketChannel* create()
  41     {
  42         return adoptRefCountedGarbageCollected(new testing::StrictMock<MockWebSocketChannel>());
  43     }
  44
  45     virtual ~MockWebSocketChannel()
  46     {
  47     }
  48
  49     MOCK_METHOD2(connect, bool(const KURL&, const String&));
  50     MOCK_METHOD1(send, void(const String&));
  51     MOCK_METHOD3(send, void(const ArrayBuffer&, unsigned, unsigned));
  52     MOCK_METHOD1(send, void(PassRefPtr<BlobDataHandle>));
  53     MOCK_METHOD1(send, void(PassOwnPtr<Vector<char> >));
  54     MOCK_CONST_METHOD0(bufferedAmount, unsigned long());
  55     MOCK_METHOD2(close, void(int, const String&));
  56     MOCK_METHOD4(fail, void(const String&, MessageLevel, const String&, unsigned));
  57     MOCK_METHOD0(disconnect, void());
  58     MOCK_METHOD0(suspend, void());
  59     MOCK_METHOD0(resume, void());
  60
  61     MockWebSocketChannel()
  62     {
  63     }
  64 };
  65
  66 class DOMWebSocketWithMockChannel FINAL : public DOMWebSocket {
  67 public:
  68     static DOMWebSocketWithMockChannel* create(ExecutionContext* context)
  69     {
  70         DOMWebSocketWithMockChannel* websocket = adoptRefCountedGarbageCollectedWillBeNoop(new DOMWebSocketWithMockChannel(context));
  71         websocket->suspendIfNeeded();
  72         return websocket;
  73     }
  74
  75     MockWebSocketChannel* channel() { return m_channel.get(); }
  76
  77     virtual WebSocketChannel* createChannel(ExecutionContext*, WebSocketChannelClient*) OVERRIDE
  78     {
  79         ASSERT(!m_hasCreatedChannel);
  80         m_hasCreatedChannel = true;
  81         return m_channel.get();
  82     }
  83
  84     virtual void trace(Visitor* visitor) OVERRIDE
  85     {
  86         visitor->trace(m_channel);
  87         DOMWebSocket::trace(visitor);
  88     }
  89
  90 private:
  91     DOMWebSocketWithMockChannel(ExecutionContext* context)
  92         : DOMWebSocket(context)
  93         , m_channel(MockWebSocketChannel::create())
  94         , m_hasCreatedChannel(false) { }
  95
  96     Member<MockWebSocketChannel> m_channel;
  97     bool m_hasCreatedChannel;
  98 };
  99
 100 class DOMWebSocketTestBase {
 101 public:
 102     DOMWebSocketTestBase()
 103         : m_pageHolder(DummyPageHolder::create())
 104         , m_websocket(DOMWebSocketWithMockChannel::create(&m_pageHolder->document()))
 105         , m_executionScope(v8::Isolate::GetCurrent())
 106         , m_exceptionState(ExceptionState::ConstructionContext, "property", "interface", m_executionScope.scriptState()->context()->Global(), m_executionScope.isolate())
 107     {
 108     }
 109
 110     virtual ~DOMWebSocketTestBase()
 111     {
 112         if (!m_websocket)
 113             return;
 114         // These statements are needed to clear WebSocket::m_channel to
 115         // avoid ASSERTION failure on ~WebSocket.
 116         ASSERT(m_websocket->channel());
 117         ::testing::Mock::VerifyAndClear(m_websocket->channel());
 118         EXPECT_CALL(channel(), disconnect()).Times(AnyNumber());
 119
 120         m_websocket->didClose(WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
 121         m_websocket.clear();
 122         Heap::collectAllGarbage();
 123     }
 124
 125     MockWebSocketChannel& channel() { return *m_websocket->channel(); }
 126
 127     OwnPtr<DummyPageHolder> m_pageHolder;
 128     Persistent<DOMWebSocketWithMockChannel> m_websocket;
 129     V8TestingScope m_executionScope;
 130     ExceptionState m_exceptionState;
 131 };
 132
 133 class DOMWebSocketTest : public DOMWebSocketTestBase, public ::testing::Test {
 134 public:
 135 };
 136
 137 TEST_F(DOMWebSocketTest, connectToBadURL)
 138 {
 139     m_websocket->connect("xxx", Vector<String>(), m_exceptionState);
 140
 141
 142     EXPECT_TRUE(m_exceptionState.hadException());
 143     EXPECT_EQ(SyntaxError, m_exceptionState.code());
 144     EXPECT_EQ("The URL 'xxx' is invalid.", m_exceptionState.message());
 145     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 146 }
 147
 148 TEST_F(DOMWebSocketTest, connectToNonWsURL)
 149 {
 150     m_websocket->connect("http://example.com/", Vector<String>(), m_exceptionState);
 151
 152
 153     EXPECT_TRUE(m_exceptionState.hadException());
 154     EXPECT_EQ(SyntaxError, m_exceptionState.code());
 155     EXPECT_EQ("The URL's scheme must be either 'ws' or 'wss'. 'http' is not allowed.", m_exceptionState.message());
 156     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 157 }
 158
 159 TEST_F(DOMWebSocketTest, connectToURLHavingFragmentIdentifier)
 160 {
 161     m_websocket->connect("ws://example.com/#fragment", Vector<String>(), m_exceptionState);
 162
 163
 164     EXPECT_TRUE(m_exceptionState.hadException());
 165     EXPECT_EQ(SyntaxError, m_exceptionState.code());
 166     EXPECT_EQ("The URL contains a fragment identifier ('fragment'). Fragment identifiers are not allowed in WebSocket URLs.", m_exceptionState.message());
 167     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 168 }
 169
 170 TEST_F(DOMWebSocketTest, invalidPort)
 171 {
 172     m_websocket->connect("ws://example.com:7", Vector<String>(), m_exceptionState);
 173
 174
 175     EXPECT_TRUE(m_exceptionState.hadException());
 176     EXPECT_EQ(SecurityError, m_exceptionState.code());
 177     EXPECT_EQ("The port 7 is not allowed.", m_exceptionState.message());
 178     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 179 }
 180
 181 // FIXME: Add a test for Content Security Policy.
 182
 183 TEST_F(DOMWebSocketTest, invalidSubprotocols)
 184 {
 185     Vector<String> subprotocols;
 186     subprotocols.append("@subprotocol-|'\"x\x01\x02\x03x");
 187
 188     {
 189         InSequence s;
 190         EXPECT_CALL(channel(), disconnect());
 191     }
 192
 193     m_websocket->connect("ws://example.com/", subprotocols, m_exceptionState);
 194
 195     EXPECT_TRUE(m_exceptionState.hadException());
 196     EXPECT_EQ(SyntaxError, m_exceptionState.code());
 197     EXPECT_EQ("The subprotocol '@subprotocol-|'\"x\\u0001\\u0002\\u0003x' is invalid.", m_exceptionState.message());
 198     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 199 }
 200
 201 TEST_F(DOMWebSocketTest, channelConnectSuccess)
 202 {
 203     Vector<String> subprotocols;
 204     subprotocols.append("aa");
 205     subprotocols.append("bb");
 206
 207     {
 208         InSequence s;
 209         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/hoge"), String("aa, bb"))).WillOnce(Return(true));
 210     }
 211
 212     m_websocket->connect("ws://example.com/hoge", Vector<String>(subprotocols), m_exceptionState);
 213
 214
 215     EXPECT_FALSE(m_exceptionState.hadException());
 216     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 217     EXPECT_EQ(KURL(KURL(), "ws://example.com/hoge"), m_websocket->url());
 218 }
 219
 220 TEST_F(DOMWebSocketTest, channelConnectFail)
 221 {
 222     Vector<String> subprotocols;
 223     subprotocols.append("aa");
 224     subprotocols.append("bb");
 225
 226     {
 227         InSequence s;
 228         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(false));
 229         EXPECT_CALL(channel(), disconnect());
 230     }
 231
 232     m_websocket->connect("ws://example.com/", Vector<String>(subprotocols), m_exceptionState);
 233
 234
 235     EXPECT_TRUE(m_exceptionState.hadException());
 236     EXPECT_EQ(SecurityError, m_exceptionState.code());
 237     EXPECT_EQ("An insecure WebSocket connection may not be initiated from a page loaded over HTTPS.", m_exceptionState.message());
 238     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 239 }
 240
 241 TEST_F(DOMWebSocketTest, isValidSubprotocolString)
 242 {
 243     EXPECT_TRUE(DOMWebSocket::isValidSubprotocolString("Helloworld!!"));
 244     EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString("Hello, world!!"));
 245     EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString(String()));
 246     EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString(""));
 247
 248     const char validCharacters[] = "!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~";
 249     size_t length = strlen(validCharacters);
 250     for (size_t i = 0; i < length; ++i) {
 251         String s;
 252         s.append(static_cast<UChar>(validCharacters[i]));
 253         EXPECT_TRUE(DOMWebSocket::isValidSubprotocolString(s));
 254     }
 255     for (size_t i = 0; i < 256; ++i) {
 256         if (std::find(validCharacters, validCharacters + length, static_cast<char>(i)) != validCharacters + length) {
 257             continue;
 258         }
 259         String s;
 260         s.append(static_cast<UChar>(i));
 261         EXPECT_FALSE(DOMWebSocket::isValidSubprotocolString(s));
 262     }
 263 }
 264
 265 TEST_F(DOMWebSocketTest, connectSuccess)
 266 {
 267     Vector<String> subprotocols;
 268     subprotocols.append("aa");
 269     subprotocols.append("bb");
 270     {
 271         InSequence s;
 272         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String("aa, bb"))).WillOnce(Return(true));
 273     }
 274     m_websocket->connect("ws://example.com/", subprotocols, m_exceptionState);
 275
 276     EXPECT_FALSE(m_exceptionState.hadException());
 277     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 278
 279     m_websocket->didConnect("bb", "cc");
 280
 281     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 282     EXPECT_EQ("bb", m_websocket->protocol());
 283     EXPECT_EQ("cc", m_websocket->extensions());
 284 }
 285
 286 TEST_F(DOMWebSocketTest, didClose)
 287 {
 288     {
 289         InSequence s;
 290         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 291         EXPECT_CALL(channel(), disconnect());
 292     }
 293     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 294
 295     EXPECT_FALSE(m_exceptionState.hadException());
 296     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 297
 298     m_websocket->didClose(WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
 299
 300     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 301 }
 302
 303 TEST_F(DOMWebSocketTest, maximumReasonSize)
 304 {
 305     {
 306         InSequence s;
 307         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 308         EXPECT_CALL(channel(), fail(_, _, _, _));
 309     }
 310     String reason;
 311     for (size_t i = 0; i < 123; ++i)
 312         reason.append("a");
 313     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 314
 315     EXPECT_FALSE(m_exceptionState.hadException());
 316     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 317
 318     m_websocket->close(1000, reason, m_exceptionState);
 319
 320     EXPECT_FALSE(m_exceptionState.hadException());
 321     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 322 }
 323
 324 TEST_F(DOMWebSocketTest, reasonSizeExceeding)
 325 {
 326     {
 327         InSequence s;
 328         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 329     }
 330     String reason;
 331     for (size_t i = 0; i < 124; ++i)
 332         reason.append("a");
 333     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 334
 335     EXPECT_FALSE(m_exceptionState.hadException());
 336     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 337
 338     m_websocket->close(1000, reason, m_exceptionState);
 339
 340     EXPECT_TRUE(m_exceptionState.hadException());
 341     EXPECT_EQ(SyntaxError, m_exceptionState.code());
 342     EXPECT_EQ("The message must not be greater than 123 bytes.", m_exceptionState.message());
 343     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 344 }
 345
 346 TEST_F(DOMWebSocketTest, closeWhenConnecting)
 347 {
 348     {
 349         InSequence s;
 350         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 351         EXPECT_CALL(channel(), fail(String("WebSocket is closed before the connection is established."), WarningMessageLevel, String(), 0));
 352     }
 353     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 354
 355     EXPECT_FALSE(m_exceptionState.hadException());
 356     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 357
 358     m_websocket->close(1000, "bye", m_exceptionState);
 359
 360     EXPECT_FALSE(m_exceptionState.hadException());
 361     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 362 }
 363
 364 TEST_F(DOMWebSocketTest, close)
 365 {
 366     {
 367         InSequence s;
 368         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 369         EXPECT_CALL(channel(), close(3005, String("bye")));
 370     }
 371     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 372
 373     EXPECT_FALSE(m_exceptionState.hadException());
 374     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 375
 376     m_websocket->didConnect("", "");
 377     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 378     m_websocket->close(3005, "bye", m_exceptionState);
 379
 380     EXPECT_FALSE(m_exceptionState.hadException());
 381     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 382 }
 383
 384 TEST_F(DOMWebSocketTest, closeWithoutReason)
 385 {
 386     {
 387         InSequence s;
 388         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 389         EXPECT_CALL(channel(), close(3005, String()));
 390     }
 391     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 392
 393     EXPECT_FALSE(m_exceptionState.hadException());
 394     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 395
 396     m_websocket->didConnect("", "");
 397     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 398     m_websocket->close(3005, m_exceptionState);
 399
 400     EXPECT_FALSE(m_exceptionState.hadException());
 401     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 402 }
 403
 404 TEST_F(DOMWebSocketTest, closeWithoutCodeAndReason)
 405 {
 406     {
 407         InSequence s;
 408         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 409         EXPECT_CALL(channel(), close(-1, String()));
 410     }
 411     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 412
 413     EXPECT_FALSE(m_exceptionState.hadException());
 414     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 415
 416     m_websocket->didConnect("", "");
 417     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 418     m_websocket->close(m_exceptionState);
 419
 420     EXPECT_FALSE(m_exceptionState.hadException());
 421     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 422 }
 423
 424 TEST_F(DOMWebSocketTest, closeWhenClosing)
 425 {
 426     {
 427         InSequence s;
 428         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 429         EXPECT_CALL(channel(), close(-1, String()));
 430     }
 431     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 432
 433     EXPECT_FALSE(m_exceptionState.hadException());
 434     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 435
 436     m_websocket->didConnect("", "");
 437     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 438     m_websocket->close(m_exceptionState);
 439     EXPECT_FALSE(m_exceptionState.hadException());
 440     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 441
 442     m_websocket->close(m_exceptionState);
 443
 444     EXPECT_FALSE(m_exceptionState.hadException());
 445     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 446 }
 447
 448 TEST_F(DOMWebSocketTest, closeWhenClosed)
 449 {
 450     {
 451         InSequence s;
 452         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 453         EXPECT_CALL(channel(), close(-1, String()));
 454         EXPECT_CALL(channel(), disconnect());
 455     }
 456     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 457
 458     EXPECT_FALSE(m_exceptionState.hadException());
 459     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 460
 461     m_websocket->didConnect("", "");
 462     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 463     m_websocket->close(m_exceptionState);
 464     EXPECT_FALSE(m_exceptionState.hadException());
 465     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 466
 467     m_websocket->didClose(WebSocketChannelClient::ClosingHandshakeComplete, 1000, String());
 468     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 469     m_websocket->close(m_exceptionState);
 470
 471     EXPECT_FALSE(m_exceptionState.hadException());
 472     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 473 }
 474
 475 TEST_F(DOMWebSocketTest, sendStringWhenConnecting)
 476 {
 477     {
 478         InSequence s;
 479         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 480     }
 481     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 482
 483     EXPECT_FALSE(m_exceptionState.hadException());
 484
 485     m_websocket->send("hello", m_exceptionState);
 486
 487     EXPECT_TRUE(m_exceptionState.hadException());
 488     EXPECT_EQ(InvalidStateError, m_exceptionState.code());
 489     EXPECT_EQ("Still in CONNECTING state.", m_exceptionState.message());
 490     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 491 }
 492
 493 TEST_F(DOMWebSocketTest, sendStringWhenClosing)
 494 {
 495     Checkpoint checkpoint;
 496     {
 497         InSequence s;
 498         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 499         EXPECT_CALL(channel(), fail(_, _, _, _));
 500     }
 501     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 502
 503     EXPECT_FALSE(m_exceptionState.hadException());
 504
 505     m_websocket->close(m_exceptionState);
 506     EXPECT_FALSE(m_exceptionState.hadException());
 507
 508     m_websocket->send("hello", m_exceptionState);
 509
 510     EXPECT_FALSE(m_exceptionState.hadException());
 511     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 512 }
 513
 514 TEST_F(DOMWebSocketTest, sendStringWhenClosed)
 515 {
 516     Checkpoint checkpoint;
 517     {
 518         InSequence s;
 519         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 520         EXPECT_CALL(channel(), disconnect());
 521         EXPECT_CALL(checkpoint, Call(1));
 522     }
 523     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 524
 525     EXPECT_FALSE(m_exceptionState.hadException());
 526
 527     m_websocket->didClose(WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
 528     checkpoint.Call(1);
 529
 530     m_websocket->send("hello", m_exceptionState);
 531
 532     EXPECT_FALSE(m_exceptionState.hadException());
 533     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 534 }
 535
 536 TEST_F(DOMWebSocketTest, sendStringSuccess)
 537 {
 538     {
 539         InSequence s;
 540         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 541         EXPECT_CALL(channel(), send(String("hello")));
 542     }
 543     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 544
 545     EXPECT_FALSE(m_exceptionState.hadException());
 546
 547     m_websocket->didConnect("", "");
 548     m_websocket->send("hello", m_exceptionState);
 549
 550     EXPECT_FALSE(m_exceptionState.hadException());
 551     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 552 }
 553
 554 TEST_F(DOMWebSocketTest, sendArrayBufferWhenConnecting)
 555 {
 556     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
 557     {
 558         InSequence s;
 559         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 560     }
 561     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 562
 563     EXPECT_FALSE(m_exceptionState.hadException());
 564
 565     m_websocket->send(view->buffer().get(), m_exceptionState);
 566
 567     EXPECT_TRUE(m_exceptionState.hadException());
 568     EXPECT_EQ(InvalidStateError, m_exceptionState.code());
 569     EXPECT_EQ("Still in CONNECTING state.", m_exceptionState.message());
 570     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 571 }
 572
 573 TEST_F(DOMWebSocketTest, sendArrayBufferWhenClosing)
 574 {
 575     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
 576     {
 577         InSequence s;
 578         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 579         EXPECT_CALL(channel(), fail(_, _, _, _));
 580     }
 581     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 582
 583     EXPECT_FALSE(m_exceptionState.hadException());
 584
 585     m_websocket->close(m_exceptionState);
 586     EXPECT_FALSE(m_exceptionState.hadException());
 587
 588     m_websocket->send(view->buffer().get(), m_exceptionState);
 589
 590     EXPECT_FALSE(m_exceptionState.hadException());
 591     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 592 }
 593
 594 TEST_F(DOMWebSocketTest, sendArrayBufferWhenClosed)
 595 {
 596     Checkpoint checkpoint;
 597     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
 598     {
 599         InSequence s;
 600         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 601         EXPECT_CALL(channel(), disconnect());
 602         EXPECT_CALL(checkpoint, Call(1));
 603     }
 604     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 605
 606     EXPECT_FALSE(m_exceptionState.hadException());
 607
 608     m_websocket->didClose(WebSocketChannelClient::ClosingHandshakeIncomplete, 1006, "");
 609     checkpoint.Call(1);
 610
 611     m_websocket->send(view->buffer().get(), m_exceptionState);
 612
 613     EXPECT_FALSE(m_exceptionState.hadException());
 614     EXPECT_EQ(DOMWebSocket::CLOSED, m_websocket->readyState());
 615 }
 616
 617 TEST_F(DOMWebSocketTest, sendArrayBufferSuccess)
 618 {
 619     RefPtr<ArrayBufferView> view = Uint8Array::create(8);
 620     {
 621         InSequence s;
 622         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 623         EXPECT_CALL(channel(), send(Ref(*view->buffer()), 0, 8));
 624     }
 625     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 626
 627     EXPECT_FALSE(m_exceptionState.hadException());
 628
 629     m_websocket->didConnect("", "");
 630     m_websocket->send(view->buffer().get(), m_exceptionState);
 631
 632     EXPECT_FALSE(m_exceptionState.hadException());
 633     EXPECT_EQ(DOMWebSocket::OPEN, m_websocket->readyState());
 634 }
 635
 636 // FIXME: We should have Blob tests here.
 637 // We can't create a Blob because the blob registration cannot be mocked yet.
 638
 639 // FIXME: We should add tests for bufferedAmount.
 640
 641 // FIXME: We should add tests for data receiving.
 642
 643 TEST_F(DOMWebSocketTest, binaryType)
 644 {
 645     EXPECT_EQ("blob", m_websocket->binaryType());
 646
 647     m_websocket->setBinaryType("hoge");
 648
 649     EXPECT_EQ("blob", m_websocket->binaryType());
 650
 651     m_websocket->setBinaryType("arraybuffer");
 652
 653     EXPECT_EQ("arraybuffer", m_websocket->binaryType());
 654
 655     m_websocket->setBinaryType("fuga");
 656
 657     EXPECT_EQ("arraybuffer", m_websocket->binaryType());
 658
 659     m_websocket->setBinaryType("blob");
 660
 661     EXPECT_EQ("blob", m_websocket->binaryType());
 662 }
 663
 664 // FIXME: We should add tests for suspend / resume.
 665
 666 class DOMWebSocketValidClosingTest : public DOMWebSocketTestBase, public ::testing::TestWithParam<unsigned short> {
 667 public:
 668 };
 669
 670 TEST_P(DOMWebSocketValidClosingTest, test)
 671 {
 672     {
 673         InSequence s;
 674         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 675         EXPECT_CALL(channel(), fail(_, _, _, _));
 676     }
 677     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 678
 679     EXPECT_FALSE(m_exceptionState.hadException());
 680     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 681
 682     m_websocket->close(GetParam(), "bye", m_exceptionState);
 683
 684     EXPECT_FALSE(m_exceptionState.hadException());
 685     EXPECT_EQ(DOMWebSocket::CLOSING, m_websocket->readyState());
 686 }
 687
 688 INSTANTIATE_TEST_CASE_P(DOMWebSocketValidClosing, DOMWebSocketValidClosingTest, ::testing::Values(1000, 3000, 3001, 4998, 4999));
 689
 690 class DOMWebSocketInvalidClosingCodeTest : public DOMWebSocketTestBase, public ::testing::TestWithParam<unsigned short> {
 691 public:
 692 };
 693
 694 TEST_P(DOMWebSocketInvalidClosingCodeTest, test)
 695 {
 696     {
 697         InSequence s;
 698         EXPECT_CALL(channel(), connect(KURL(KURL(), "ws://example.com/"), String())).WillOnce(Return(true));
 699     }
 700     m_websocket->connect("ws://example.com/", Vector<String>(), m_exceptionState);
 701
 702     EXPECT_FALSE(m_exceptionState.hadException());
 703     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 704
 705     m_websocket->close(GetParam(), "bye", m_exceptionState);
 706
 707     EXPECT_TRUE(m_exceptionState.hadException());
 708     EXPECT_EQ(InvalidAccessError, m_exceptionState.code());
 709     EXPECT_EQ(String::format("The code must be either 1000, or between 3000 and 4999. %d is neither.", GetParam()), m_exceptionState.message());
 710     EXPECT_EQ(DOMWebSocket::CONNECTING, m_websocket->readyState());
 711 }
 712
 713 INSTANTIATE_TEST_CASE_P(DOMWebSocketInvalidClosingCode, DOMWebSocketInvalidClosingCodeTest, ::testing::Values(0, 1, 998, 999, 1001, 2999, 5000, 9999, 65535));
 714
 715 } // namespace
 716
 717 } // namespace blink