gecko/content/base/test/test_websocket.html

<!DOCTYPE HTML>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
  <title>WebSocket test</title>
  <script type="text/javascript" src="/MochiKit/packed.js"></script>
  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body onload="testWebSocket()">
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=472529">Mozilla Bug </a>
<p id="display"></p>
<div id="content">
</div>
<pre id="test">
<script class="testbody" type="text/javascript">

/*
 * tests:
 *  1. client tries to connect to a http scheme location;
 *  2. assure serialization of the connections;
 *  3. client tries to connect to an non-existent ws server;
 *  4. client tries to connect using a relative url;
 *  5. client uses an invalid protocol value;
 *  6. counter and encoding check;
 *  7. client calls close() and the server keeps sending messages and it doesn't
 *     send the close frame;
 *  8. client calls close() and the server sends the close frame in
 *     acknowledgement;
 *  9. client closes the connection before the ws connection is established;
 * 10. client sends a message before the ws connection is established;
 * 11. a simple hello echo;
 * 12. client sends a message with bad bytes;
 * 13. server sends an invalid message;
 * 14. server sends the close frame, it doesn't close the tcp connection and
 *     it keeps sending normal ws messages;
 * 15. server closes the tcp connection, but it doesn't send the close frame;
 * 16. client calls close() and tries to send a message;
 * 17. see bug 572975 - all event listeners set
 * 18. client tries to connect to an http resource;
 * 19. server closes the tcp connection before establishing the ws connection;
 * 20. see bug 572975 - only on error and onclose event listeners set
 * 21. see bug 572975 - same as test 17, but delete strong event listeners when
 *     receiving the message event;
 * 22. server takes too long to establish the ws connection;
 * 23. see bug 664692 - feature detection should detect MozWebSocket but not
 *     WebSocket on window object;
 * 24. server rejects sub-protocol string
 * 25. ctor with valid empty sub-protocol array
 * 26. ctor with invalid sub-protocol array containing 1 empty element
 * 27. ctor with invalid sub-protocol array containing an empty element in list
 * 28. ctor using valid 1 element sub-protocol array
 * 29. ctor using all valid 5 element sub-protocol array
 * 30. ctor using valid 1 element sub-protocol array with element server will
 *     reject
 * 31. ctor using valid 2 element sub-protocol array with 1 element server
 *     will reject and one server will accept.
 * 32. ctor using invalid sub-protocol array that contains duplicate items
 */

var first_test = 1;
var last_test = 32;

var current_test = first_test;

var timeoutToAbortTest = 60000;
var all_ws = [];

function shouldNotOpen(e)
{
  var ws = e.target;
  ok(false, "onopen shouldn't be called on test " + ws._testNumber + "!");
}

function shouldNotReceiveCloseEvent(e)
{
  var ws = e.target;
  var extendedErrorInfo = "";
  if (!ws._testNumber) {
    extendedErrorInfo += "\nws members:\n";
    for (var i in ws) {
      extendedErrorInfo += (i + ": " + ws[i] + "\n");
    }

    extendedErrorInfo += "\ne members:\n";
    for (var i in e) {
      extendedErrorInfo += (i + ": " + e[i] + "\n");
    }
  }
  
  // FIXME: see bug 578276. This should be a test failure, but it's too flaky on the tbox.
  ok(true, "onclose shouldn't be called on test " + ws._testNumber + "!" + extendedErrorInfo);
}

function shouldCloseCleanly(e)
{
  var ws = e.target;
  ok(e.wasClean, "the ws connection in test " + ws._testNumber + " should be closed cleanly");
}

function shouldCloseNotCleanly(e)
{
  var ws = e.target;
  ok(!e.wasClean, "the ws connection in test " + ws._testNumber + " shouldn't be closed cleanly");
}

function ignoreError(e)
{
}

function CreateTestWS(ws_location, ws_protocol)
{
  var ws;

  try {
    if (ws_protocol == undefined) {
      ws = new MozWebSocket(ws_location);
    } else {
      ws = new MozWebSocket(ws_location, ws_protocol);
    }


    ws._testNumber = current_test;
    ws._receivedCloseEvent = false;
    ok(true, "added testNumber: " + ws._testNumber +"\n");

    ws.onerror = function(e)
    {
      ok(false, "onerror called on test " + e.target._testNumber + "!");
    };
    ws.addEventListener("close", function(e)
    {
      ws._receivedCloseEvent = true;
    }, false);
  }
  catch (e) {
    throw e;
  }
  finally {
    current_test++;
  }

  all_ws.push(ws);
  return ws;
}

function forcegc()
{
  SpecialPowers.forceGC();
  SpecialPowers.gc();
  setTimeout(function()
  {
    SpecialPowers.gc();
  }, 1);
}

function doTest(number)
{
  if (doTest.timeoutId !== null) {
    clearTimeout(doTest.timeoutId);
    doTest.timeoutId = null;
  }

  if (number > last_test) {
    setTimeout(finishWSTest, 30000);  // wait for the close events be dispatched
    return;
  }

  $("feedback").innerHTML = "executing test: " + number + " of " + last_test + " tests.";

  var fnTest = eval("test" + number + "");

  if (fnTest._started === true) {
    doTest(number + 1);
    return;
  }

  doTest.timeoutId = setTimeout(function()
  {
    ok(false, "test " + number + " took too long to finish!");
    doTest(number + 1);
  }, timeoutToAbortTest);

  fnTest._started = true;
  fnTest();
}
doTest.timeoutId = null;

function test1()
{
  try {
    var ws = CreateTestWS("http://mochi.test:8888/tests/content/base/test/file_websocket");
    ok(false, "test1 failed");
  }
  catch (e) {
    ok(true, "test1 failed");
  }
  doTest(2);
}

// this test expects that the serialization list to connect to the proxy
// is empty
function test2()
{
  var ws1 = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-2.1");
  current_test--; // CreateTestWS incremented this
  var ws2 = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-2.2");

  var ws2CanConnect = false;

  // the server will delay ws1 for 5 seconds

  ws1.onopen = function()
  {
    ws2CanConnect = true;
  }

  ws2.onopen = function()
  {
    ok(ws2CanConnect, "shouldn't connect yet in test-2!");
    doTest(3);
  }
}

function test3()
{
  var hasError = false;
  var ws = CreateTestWS("ws://this.websocket.server.probably.does.not.exist");
  ws.onopen = shouldNotOpen;
  ws.onerror = function (e)
  {
    hasError = true;
  }

  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    ok(hasError, "rcvd onerror event");
    doTest(4);
  };
}

function test4()
{
  try {
    var ws = CreateTestWS("file_websocket");
    ok(false, "test-4 failed");
  }
  catch (e) {
    ok(true, "test-4 failed");
  }
  doTest(5);
}

function test5()
{
  try {
    var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "");
    ok(false, "couldn't accept an empty string in the protocol parameter");
  }
  catch (e) {
    ok(true, "couldn't accept an empty string in the protocol parameter");
  }
  current_test--; // CreateTestWS incremented this
  try {
    var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "\n");
    ok(false, "couldn't accept any not printable ASCII character in the protocol parameter");
  }
  catch (e) {
    ok(true, "couldn't accept any not printable ASCII character in the protocol parameter");
  }
  current_test--; // CreateTestWS incremented this
  try {
    var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test 5");
    ok(false, "U+0020 not acceptable in protocol parameter");
  }
  catch (e) {
    ok(true, "U+0020 not acceptable in protocol parameter");
  }
  doTest(6);
}

function test6()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-6");
  var counter = 1;
  ws.onopen = function()
  {
    ws.send(counter);
  }
  ws.onmessage = function(e)
  {
    if (counter == 5) {
      ok(e.data == "あいうえお", "test-6 counter 5 data ok");
      ws.close();
      doTest(7);
    } else {
      ok(e.data == counter+1, "bad counter");
      counter += 2;
      ws.send(counter);
    }
  }
  ws.onclose = shouldCloseCleanly;
}

function test7()
{
// with pywebsockets for -06 ths test no longer does anything useful
// as the server handles the receipt of the close event directly, not
// as part of the wsh - so we cannot fake the non-clean close which is
// what we're trying to do here.

  ok(true, "test disabled");
  current_test++;
  doTest(8);

//  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-7");
//  ws.onopen = function()
//  {
//    ws.close();
//  }
//  ws.onclose = function(e)
//  {
//    shouldCloseNotCleanly(e);
//    doTest(8);
//  };
}

function test8()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-8");
  ws.onopen = function()
  {
    ok(ws.protocol == "test-8", "test-8 subprotocol selection");
    ws.close();
  }
  ws.onclose = function(e)
  {
    shouldCloseCleanly(e);
    doTest(9);
  };
}

function test9()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-9");
  ws.onopen = shouldNotOpen;
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(10);
  };

  ws.close();
}

function test10()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-10");
  ws.onclose = shouldCloseCleanly;

  try {
    ws.send("client data");
    ok(false, "Couldn't send data before connecting!");
  }
  catch (e) {
    ok(true, "Couldn't send data before connecting!");
  }
  ws.onopen = function()
  {
    doTest(11);
  }
}

function test11()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-11");
  ok(ws.readyState == 0, "create bad readyState in test-11!");
  ws.onopen = function()
  {
    ok(ws.readyState == 1, "open bad readyState in test-11!");
    ws.send("client data");
  }
  ws.onmessage = function(e)
  {
    ok(e.data == "server data", "bad received message in test-11!");
    ws.close();

// this ok() is disabled due to a race condition - it state may have
// advanced through 2 (closing) and into 3 (closed) before it is evald
//    ok(ws.readyState == 2, "onmessage bad readyState in test-11!");
  }
  ws.onclose = function(e)
  {
    ok(ws.readyState == 3, "onclose bad readyState in test-11!");
    shouldCloseCleanly(e);
    doTest(12);
  }
}

function test12()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-12");
  ws.onopen = function()
  {
    try {
      // send an unpaired surrogate
      ws.send(String.fromCharCode(0xD800));
      ok(false, "couldn't send an unpaired surrogate!");
    }
    catch (e) {
      ok(true, "couldn't send an unpaired surrogate!");
    }
    ws.close();

// there isnt really a server implementation of test-12, so just
// ignore an error
    ws.onerror = function()
    {
    }

    doTest(13);
  };
}

function test13()
{
    // previous versions of this test counted the number of protocol errors returned, but the 
    // protocol stack typically closes down after reporting a protocol level error - trying
    // to resync is too dangerous

  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-13");
  ws._timesCalledOnError = 0;
  ws.onerror = function()
  {
    ws._timesCalledOnError++;
  }
  ws.onclose = function(e)
  {
    ok(ws._timesCalledOnError > 0, "no error events");
    doTest(14);
  }
}

function test14()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-14");
  ws.onmessage = function()
  {
    ok(false, "shouldn't received message after the server sent the close frame");
  }
  ws.onclose = function(e)
  {
    shouldCloseCleanly(e);
    doTest(15);
  };
}

function test15()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-15");
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(16);
  };

  // termination of the connection might cause an error event if it happens in OPEN
  ws.onerror = function()
  {
  }

}

function test16()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-16");
  ws.onopen = function()
  {
    ws.close();
    ok(!ws.send("client data"), "shouldn't send message after calling close()");
    doTest(17);
  }
  ws.onmessage = function()
  {
    ok(false, "shouldn't send message after calling close()");
  }

  ws.onerror = function()
  {
  }
  ws.onclose = function()
  {
  }
}

var status_test17 = "not started";

window._test17 = function()
{
  var local_ws = new MozWebSocket("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-17");
  local_ws._testNumber = "local17";
  local_ws._testNumber = current_test++;

  status_test17 = "started";

  local_ws.onopen = function(e)
  {
    status_test17 = "opened";
    e.target.send("client data");
    forcegc();
  };

  local_ws.onerror = function()
  {
    ok(false, "onerror called on test " + e.target._testNumber + "!");
  };

  local_ws.onmessage = function(e)
  {
    ok(e.data == "server data", "Bad message in test-17");
    status_test17 = "got message";
    forcegc();
  };

  local_ws.onclose = function(e)
  {
    ok(status_test17 == "got message", "Didn't got message in test-17!");
    shouldCloseCleanly(e);
    status_test17 = "closed";
    forcegc();
    doTest(18);
    forcegc();
  };

  local_ws = null;
  window._test17 = null;
  forcegc();
}

function test17()
{
  window._test17();
}

// The tests that expects that their websockets neither open nor close MUST
// be in the end of the tests, i.e. HERE, in order to prevent blocking the other
// tests.

function test18()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket_http_resource.txt");
  ws.onopen = shouldNotOpen;
  ws.onerror = ignoreError;
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(19);
  };
}

function test19()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-19");
  ws.onopen = shouldNotOpen;
  ws.onerror = ignoreError;
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(20);
  };
}

window._test20 = function()
{
  var local_ws = new MozWebSocket("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-20");
  local_ws._testNumber = "local20";
  local_ws._testNumber = current_test++;

  local_ws.onerror = function()
  {
    ok(false, "onerror called on test " + e.target._testNumber + "!");
  };

  local_ws.onclose = function(e)
  {
    shouldCloseCleanly(e);
    doTest(21);
  };

  local_ws = null;
  window._test20 = null;
  forcegc();
}

function test20()
{
  window._test20();
}

var timeoutTest21;

window._test21 = function()
{
  var local_ws = new MozWebSocket("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-21");
  local_ws._testNumber = current_test++;

  local_ws.onopen = function(e)
  {
    e.target.send("client data");
    timeoutTest21 = setTimeout(function()
    {
      ok(false, "Didn't received message on test-21!");
    }, 15000);
    forcegc();
    e.target.onopen = null;
    forcegc();
  };

  local_ws.onerror = function()
  {
    ok(false, "onerror called on test " + e.target._testNumber + "!");
  };

  local_ws.onmessage = function(e)
  {
    clearTimeout(timeoutTest21);
    ok(e.data == "server data", "Bad message in test-21");
    forcegc();
    e.target.onmessage = null;
    forcegc();
  };

  local_ws.onclose = function(e)
  {
    shouldCloseCleanly(e);
    doTest(22);
  };

  local_ws = null;
  window._test21 = null;
  forcegc();
}

function test21()
{
  window._test21();
}

function test22()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-22");
  ws.onopen = shouldNotOpen;
  ws.onerror = ignoreError;
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(23);
  };
}

function test23()
{
  current_test++;
  is(false, "WebSocket" in window, "WebSocket shouldn't be available on window object");
  is(true, "MozWebSocket" in window, "MozWebSocket should be available on window object");
  doTest(24);
}

function test24()
{
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", "test-does-not-exist");
  ws.onopen = shouldNotOpen;
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(25);
  };
  ws.onerror = function()
  {
  }
}

function test25()
{
  var prots=[];

  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);

  // This test errors because the server requires a sub-protocol, but
  // the test just wants to ensure that the ctor doesn't generate an
  // exception
  ws.onerror = ignoreError;
  ws.onopen = shouldNotOpen;

  ws.onclose = function(e)
  {
    ok(ws.protocol == "", "test25 subprotocol selection");
    ok(true, "test 25 protocol array close");
    doTest(26);
  };
}

function test26()
{
  var prots=[""];

  try {
    var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);
    ok(false, "testing empty element sub protocol array");
  }
  catch (e) {
    ok(true, "testing empty sub element protocol array");
  }
  doTest(27);
}

function test27()
{
  var prots=["test27", ""];

  try {
    var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);
    ok(false, "testing empty element mixed sub protocol array");
  }
  catch (e) {
    ok(true, "testing empty element mixed sub protocol array");
  }
  doTest(28);
}

function test28()
{
  var prots=["test28"];

  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);
  ws.onopen = function(e)
  {
    ok(true, "test 28 protocol array open");
    ws.close();
  };

  ws.onclose = function(e)
  {
    ok(ws.protocol == "test28", "test28 subprotocol selection");
    ok(true, "test 28 protocol array close");
    doTest(29);
  };
}

function test29()
{
  var prots=["test29a", "test29b"];

  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);
  ws.onopen = function(e)
  {
    ok(true, "test 29 protocol array open");
    ws.close();
  };

  ws.onclose = function(e)
  {
    ok(true, "test 29 protocol array close");
    doTest(30);
  };
}

function test30()
{
  var prots=["test-does-not-exist"];
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);

  ws.onopen = shouldNotOpen;
  ws.onclose = function(e)
  {
    shouldCloseNotCleanly(e);
    doTest(31);
  };
  ws.onerror = function()
  {
  }
}

function test31()
{
  var prots=["test-does-not-exist", "test31"];
  var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);

  ws.onopen = function(e)
  {
    ok(true, "test 31 protocol array open");
    ws.close();
  };

  ws.onclose = function(e)
  {
    ok(ws.protocol == "test31", "test31 subprotocol selection");
    ok(true, "test 31 protocol array close");
    doTest(32);
  };
}

function test32()
{
  var prots=["test32","test32"];

  try {
    var ws = CreateTestWS("ws://mochi.test:8888/tests/content/base/test/file_websocket", prots);
    ok(false, "testing duplicated element sub protocol array");
  }
  catch (e) {
    ok(true, "testing duplicated sub element protocol array");
  }
  doTest(33);
}

function finishWSTest()
{
  for (i = 0; i < all_ws.length; ++i) {
    if (all_ws[i] != shouldNotReceiveCloseEvent &&
        !all_ws[i]._receivedCloseEvent) {
      ok(false, "didn't called close on test " + all_ws[i]._testNumber + "!");
    }
  }
  SimpleTest.finish();
}

function testWebSocket ()
{
  doTest(first_test);
}

SimpleTest.waitForExplicitFinish();

</script>
</pre>

<div id="feedback">
</div>

</body>
</html>