/node_modules/now/node_modules/socket.io/test/transports.websocket.test.js

   1
   2/*!
   3 * socket.io-node
   4 * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
   5 * MIT Licensed
   6 */
   7
   8/**
   9 * Test dependencies.
  10 */
  11
  12var sio = require('socket.io')
  13  , should = require('./common')
  14  , parser = sio.parser
  15  , ports = 15800;
  16
  17/**
  18 * Tests.
  19 */
  20
  21module.exports = {
  22
  23  'test that not responding to a heartbeat drops client': function (done) {
  24    var cl = client(++ports)
  25      , io = create(cl)
  26      , messages = 0
  27      , ws;
  28
  29    io.configure(function () {
  30      io.set('heartbeat interval', .05);
  31      io.set('heartbeat timeout', .05);
  32      io.set('close timeout', 0);
  33    });
  34
  35    io.sockets.on('connection', function (socket) {
  36      socket.on('disconnect', function (reason) {
  37        beat.should.be.true;
  38        reason.should.eql('heartbeat timeout');
  39
  40        cl.end();
  41        ws.finishClose();
  42        io.server.close();
  43        done();
  44      });
  45    });
  46
  47    cl.handshake(function (sid) {
  48      ws = websocket(cl, sid);
  49      ws.on('message', function (packet) {
  50        if (++messages == 1) {
  51          packet.type.should.eql('connect');
  52        } else {
  53          packet.type.should.eql('heartbeat');
  54          beat = true;
  55        }
  56      });
  57    });
  58  },
  59
  60  'test that responding to a heartbeat maintains session': function (done) {
  61    var cl = client(++ports)
  62      , io = create(cl)
  63      , messages = 0
  64      , heartbeats = 0
  65      , ws;
  66
  67    io.configure(function () {
  68      io.set('heartbeat interval', .05);
  69      io.set('heartbeat timeout', .05);
  70      io.set('close timeout', 0);
  71    });
  72
  73    io.sockets.on('connection', function (socket) {
  74      socket.on('disconnect', function (reason) {
  75        heartbeats.should.eql(2);
  76        reason.should.eql('heartbeat timeout');
  77
  78        cl.end();
  79        ws.finishClose();
  80        io.server.close();
  81        done();
  82      });
  83    });
  84
  85    cl.handshake(function (sid) {
  86      ws = websocket(cl, sid);
  87      ws.on('message', function (packet) {
  88        if (++messages == 1) {
  89          packet.type.should.eql('connect');
  90        } else {
  91          packet.type.should.eql('heartbeat');
  92          heartbeats++;
  93
  94          if (heartbeats == 1) {
  95            ws.packet({ type: 'heartbeat' });
  96          }
  97        }
  98      });
  99    });
 100  },
 101
 102  'test sending undeliverable volatile messages': function (done) {
 103    var cl = client(++ports)
 104      , io = create(cl)
 105      , messages = 0
 106      , messaged = false
 107      , s;
 108
 109    io.configure(function () {
 110      io.set('close timeout', .05);
 111    });
 112
 113    io.sockets.on('connection', function (socket) {
 114      s = socket;
 115
 116      socket.on('disconnect', function () {
 117        messaged.should.be.false;
 118        cl.end();
 119        io.server.close();
 120        done();
 121      });
 122    });
 123
 124    cl.handshake(function (sid) {
 125      var ws = websocket(cl, sid);
 126      ws.on('message', function (msg) {
 127        msg.type.should.eql('connect');
 128        ws.finishClose();
 129
 130        setTimeout(function () {
 131          s.volatile.send('ah wha wha');
 132
 133          ws = websocket(cl, sid);
 134          ws.on('message', function () {
 135            messaged = true;
 136          });
 137
 138          setTimeout(function () {
 139            ws.finishClose();
 140          }, 10);
 141        }, 10);
 142      });
 143    });
 144  },
 145
 146  'test sending undeliverable volatile json': function (done) {
 147    var cl = client(++ports)
 148      , io = create(cl)
 149      , messaged = false
 150      , s;
 151
 152    io.configure(function () {
 153      io.set('close timeout', .05);
 154    });
 155
 156    io.sockets.on('connection', function (socket) {
 157      s = socket;
 158
 159      socket.on('disconnect', function () {
 160        messaged.should.be.false;
 161        cl.end();
 162        io.server.close();
 163        done();
 164      });
 165    });
 166
 167    cl.handshake(function (sid) {
 168      var ws = websocket(cl, sid);
 169      ws.on('message', function () {
 170        ws.finishClose();
 171
 172        setTimeout(function () {
 173          s.volatile.json.send({ a: 'b' });
 174
 175          ws = websocket(cl, sid);
 176          ws.on('message', function () {
 177            messaged = true;
 178          });
 179
 180          setTimeout(function () {
 181            ws.finishClose();
 182          }, 10);
 183        }, 10);
 184      });
 185    });
 186  },
 187
 188  'test sending undeliverable volatile events': function (done) {
 189    var cl = client(++ports)
 190      , io = create(cl)
 191      , messaged = false
 192      , s;
 193
 194    io.configure(function () {
 195      io.set('close timeout', .05);
 196    });
 197
 198    io.sockets.on('connection', function (socket) {
 199      s = socket;
 200
 201      socket.on('disconnect', function () {
 202        messaged.should.be.false;
 203        cl.end();
 204        io.server.close();
 205        done();
 206      });
 207    });
 208
 209    cl.handshake(function (sid) {
 210      var ws = websocket(cl, sid);
 211      ws.on('message', function () {
 212        ws.finishClose();
 213
 214        setTimeout(function () {
 215          s.volatile.emit({ a: 'b' });
 216
 217          ws = websocket(cl, sid);
 218          ws.on('message', function () {
 219            messaged = true;
 220          });
 221
 222          setTimeout(function () {
 223            ws.finishClose();
 224          }, 10);
 225        }, 10);
 226      });
 227    });
 228  },
 229
 230  'test sending deliverable volatile messages': function (done) {
 231    var cl = client(++ports)
 232      , io = create(cl)
 233      , messages = 0
 234      , messaged = false;
 235
 236    io.configure(function () {
 237      io.set('close timeout', .05);
 238    });
 239
 240    io.sockets.on('connection', function (socket) {
 241      socket.volatile.send('tobi');
 242
 243      socket.on('disconnect', function () {
 244        messaged.should.be.true;
 245        cl.end();
 246        io.server.close();
 247        done();
 248      });
 249    });
 250
 251    cl.handshake(function (sid) {
 252      var ws = websocket(cl, sid);
 253      ws.on('message', function (msg) {
 254        if (++messages == 1) {
 255          msg.type.should.eql('connect');
 256        } else {
 257          msg.should.eql({
 258              type: 'message'
 259            , data: 'tobi'
 260            , endpoint: ''
 261          });
 262          messaged = true;
 263          ws.finishClose();
 264        }
 265      });
 266    });
 267  },
 268
 269  'test sending deliverable volatile json': function (done) {
 270    var cl = client(++ports)
 271      , io = create(cl)
 272      , messaged = false;
 273
 274    io.configure(function () {
 275      io.set('close timeout', .05);
 276    });
 277
 278    io.sockets.on('connection', function (socket) {
 279      socket.volatile.json.send([1, 2, 3]);
 280
 281      socket.on('disconnect', function () {
 282        messaged.should.be.true;
 283        cl.end();
 284        io.server.close();
 285        done();
 286      });
 287    });
 288
 289    cl.handshake(function (sid) {
 290      var ws = websocket(cl, sid);
 291      ws.on('message', function (msg) {
 292        if (!ws.connected) {
 293          msg.type.should.eql('connect');
 294          ws.connected = true;
 295        } else {
 296          msg.should.eql({
 297              type: 'json'
 298            , data: [1, 2, 3]
 299            , endpoint: ''
 300          });
 301          messaged = true;
 302          ws.finishClose();
 303        }
 304      });
 305    });
 306  },
 307
 308  'test sending deliverable volatile events': function (done) {
 309    var cl = client(++ports)
 310      , io = create(cl)
 311      , messaged = false;
 312
 313    io.configure(function () {
 314      io.set('close timeout', .05);
 315    });
 316
 317    io.sockets.on('connection', function (socket) {
 318      socket.volatile.emit('tobi');
 319
 320      socket.on('disconnect', function () {
 321        messaged.should.be.true;
 322        cl.end();
 323        io.server.close();
 324        done();
 325      });
 326    });
 327
 328    cl.handshake(function (sid) {
 329      var ws = websocket(cl, sid);
 330      ws.on('message', function (msg) {
 331        if (!ws.connected) {
 332          msg.type.should.eql('connect');
 333          ws.connected = true;
 334        } else {
 335          msg.should.eql({
 336              type: 'event'
 337            , name: 'tobi'
 338            , endpoint: ''
 339            , args: []
 340          });
 341          messaged = true;
 342          ws.finishClose();
 343        }
 344      });
 345    });
 346  },
 347
 348  'test sending to all clients in a namespace': function (done) {
 349    var port = ++ports
 350      , cl1 = client(port)
 351      , cl2 = client(port)
 352      , io = create(cl1)
 353      , messages = 0
 354      , connections = 0
 355      , disconnections = 0;
 356
 357    io.configure(function () {
 358      io.set('close timeout', 0);
 359    });
 360
 361    io.sockets.on('connection', function (socket) {
 362      connections++;
 363
 364      if (connections == 2) {
 365        io.sockets.send('yup');
 366      }
 367
 368      socket.on('disconnect', function () {
 369        disconnections++;
 370
 371        if (disconnections == 2) {
 372          messages.should.eql(2);
 373          cl1.end();
 374          cl2.end();
 375          io.server.close();
 376          done();
 377        }
 378      });
 379    });
 380
 381    cl1.handshake(function (sid) {
 382      var ws1 = websocket(cl1, sid);
 383      ws1.on('message', function (msg) {
 384        if (!ws1.connected) {
 385          msg.type.should.eql('connect');
 386          ws1.connected = true;
 387        } else {
 388          msg.should.eql({
 389              type: 'message'
 390            , data: 'yup'
 391            , endpoint: ''
 392          });
 393
 394          messages++;
 395          ws1.finishClose();
 396        }
 397      });
 398    });
 399
 400    cl2.handshake(function (sid) {
 401      var ws2 = websocket(cl2, sid);
 402      ws2.on('message', function (msg) {
 403        if (!ws2.connected) {
 404          msg.type.should.eql('connect');
 405          ws2.connected = true;
 406        } else {
 407          msg.should.eql({
 408              type: 'message'
 409            , data: 'yup'
 410            , endpoint: ''
 411          });
 412
 413          messages++;
 414          ws2.finishClose();
 415        }
 416      });
 417    });
 418  },
 419
 420  'test sending json to all clients in a namespace': function (done) {
 421    var port = ++ports
 422      , cl1 = client(port)
 423      , cl2 = client(port)
 424      , io = create(cl1)
 425      , messages = 0
 426      , connections = 0
 427      , disconnections = 0;
 428
 429    io.configure(function () {
 430      io.set('close timeout', 0);
 431    });
 432
 433    io.sockets.on('connection', function (socket) {
 434      connections++;
 435
 436      if (connections == 2) {
 437        io.sockets.json.send({ a: 'b' });
 438      }
 439
 440      socket.on('disconnect', function () {
 441        disconnections++;
 442
 443        if (disconnections == 2) {
 444          messages.should.eql(2);
 445          cl1.end();
 446          cl2.end();
 447          io.server.close();
 448          done();
 449        }
 450      });
 451    });
 452
 453    cl1.handshake(function (sid) {
 454      var ws1 = websocket(cl1, sid);
 455      ws1.on('message', function (msg) {
 456        if (!ws1.connected) {
 457          msg.type.should.eql('connect');
 458          ws1.connected = true;
 459        } else {
 460          msg.should.eql({
 461              type: 'json'
 462            , data: { a: 'b' }
 463            , endpoint: ''
 464          });
 465
 466          messages++;
 467          ws1.finishClose();
 468        }
 469      });
 470    });
 471
 472    cl2.handshake(function (sid) {
 473      var ws2 = websocket(cl2, sid);
 474      ws2.on('message', function (msg) {
 475        if (!ws2.connected) {
 476          msg.type.should.eql('connect');
 477          ws2.connected = true;
 478        } else {
 479          msg.should.eql({
 480              type: 'json'
 481            , data: { a: 'b' }
 482            , endpoint: ''
 483          });
 484
 485          messages++;
 486          ws2.finishClose();
 487        }
 488      });
 489    });
 490  },
 491
 492  'test emitting to all clients in a namespace': function (done) {
 493    var port = ++ports
 494      , cl1 = client(port)
 495      , cl2 = client(port)
 496      , io = create(cl1)
 497      , messages = 0
 498      , connections = 0
 499      , disconnections = 0;
 500
 501    io.configure(function () {
 502      io.set('close timeout', 0);
 503    });
 504
 505    io.sockets.on('connection', function (socket) {
 506      connections++;
 507
 508      if (connections == 2) {
 509        io.sockets.emit('tobi', 'rapture');
 510      }
 511
 512      socket.on('disconnect', function () {
 513        disconnections++;
 514
 515        if (disconnections == 2) {
 516          messages.should.eql(2);
 517          cl1.end();
 518          cl2.end();
 519          io.server.close();
 520          done();
 521        }
 522      });
 523    });
 524
 525    cl1.handshake(function (sid) {
 526      var ws1 = websocket(cl1, sid);
 527      ws1.on('message', function (msg) {
 528        if (!ws1.connected) {
 529          msg.type.should.eql('connect');
 530          ws1.connected = true;
 531        } else {
 532          msg.should.eql({
 533              type: 'event'
 534            , name: 'tobi'
 535            , args: ['rapture']
 536            , endpoint: ''
 537          });
 538
 539          messages++;
 540          ws1.finishClose();
 541        }
 542      });
 543    });
 544
 545    cl2.handshake(function (sid) {
 546      var ws2 = websocket(cl2, sid);
 547      ws2.on('message', function (msg) {
 548        if (!ws2.connected) {
 549          msg.type.should.eql('connect');
 550          ws2.connected = true;
 551        } else {
 552          msg.should.eql({
 553              type: 'event'
 554            , name: 'tobi'
 555            , args: ['rapture']
 556            , endpoint: ''
 557          });
 558
 559          messages++;
 560          ws2.finishClose();
 561        }
 562      });
 563    });
 564  },
 565
 566  'test sending to all clients in a room': function (done) {
 567    var port = ++ports
 568      , cl1 = client(port)
 569      , cl2 = client(port)
 570      , cl3 = client(port)
 571      , io = create(cl1)
 572      , messages = 0
 573      , joins = 0
 574      , connections = 0
 575      , disconnections = 0;
 576
 577    io.configure(function () {
 578      io.set('close timeout', 0);
 579    });
 580
 581    io.sockets.on('connection', function (socket) {
 582      connections++;
 583
 584      if (connections != 3) {
 585        socket.join('woot');
 586        joins++;
 587
 588        if (joins == 2) {
 589          setTimeout(function () {
 590            connections.should.eql(3);
 591            io.sockets.in('woot').send('hahaha');
 592          }, 20);
 593        }
 594      }
 595
 596      socket.on('disconnect', function () {
 597        disconnections++;
 598
 599        if (disconnections == 3) {
 600          messages.should.eql(2);
 601          cl1.end();
 602          cl2.end();
 603          cl3.end();
 604          io.server.close();
 605          done();
 606        }
 607      });
 608    });
 609
 610    cl1.handshake(function (sid) {
 611      var ws1 = websocket(cl1, sid);
 612      ws1.on('message', function (msg) {
 613        if (!ws1.connected) {
 614          msg.type.should.eql('connect');
 615          ws1.connected = true;
 616        } else {
 617          msg.should.eql({
 618              type: 'message'
 619            , data: 'hahaha'
 620            , endpoint: ''
 621          });
 622
 623          messages++;
 624        }
 625      });
 626
 627      setTimeout(function () {
 628        ws1.finishClose();
 629      }, 50);
 630    });
 631
 632    cl2.handshake(function (sid) {
 633      var ws2 = websocket(cl2, sid);
 634      ws2.on('message', function (msg) {
 635        if (!ws2.connected) {
 636          msg.type.should.eql('connect');
 637          ws2.connected = true;
 638        } else {
 639          msg.should.eql({
 640              type: 'message'
 641            , data: 'hahaha'
 642            , endpoint: ''
 643          });
 644
 645          messages++;
 646        }
 647      });
 648
 649      setTimeout(function () {
 650        ws2.finishClose();
 651      }, 50);
 652    });
 653
 654    cl3.handshake(function (sid) {
 655      var ws3 = websocket(cl3, sid);
 656      ws3.on('message', function (msg) {
 657        if (!ws3.connected) {
 658          msg.type.should.eql('connect');
 659          ws3.connected = true;
 660        } else {
 661          msg.should.eql({
 662              type: 'message'
 663            , data: 'hahaha'
 664            , endpoint: ''
 665          });
 666
 667          messages++;
 668        }
 669      });
 670
 671      setTimeout(function () {
 672        ws3.finishClose();
 673      }, 50);
 674    });
 675  },
 676
 677  'test sending json to all clients in a room': function (done) {
 678    var port = ++ports
 679      , cl1 = client(port)
 680      , cl2 = client(port)
 681      , cl3 = client(port)
 682      , io = create(cl1)
 683      , messages = 0
 684      , joins = 0
 685      , connections = 0
 686      , disconnections = 0;
 687
 688    io.configure(function () {
 689      io.set('close timeout', 0);
 690    });
 691
 692    io.sockets.on('connection', function (socket) {
 693      connections++;
 694
 695      if (connections != 3) {
 696        socket.join('woot');
 697        joins++;
 698
 699        if (joins == 2) {
 700          setTimeout(function () {
 701            connections.should.eql(3);
 702            io.sockets.in('woot').json.send(123);
 703          }, 20);
 704        }
 705      }
 706
 707      socket.on('disconnect', function () {
 708        disconnections++;
 709
 710        if (disconnections == 3) {
 711          messages.should.eql(2);
 712          cl1.end();
 713          cl2.end();
 714          cl3.end();
 715          io.server.close();
 716          done();
 717        }
 718      });
 719    });
 720
 721    cl1.handshake(function (sid) {
 722      var ws1 = websocket(cl1, sid);
 723      ws1.on('message', function (msg) {
 724        if (!ws1.connected) {
 725          msg.type.should.eql('connect');
 726          ws1.connected = true;
 727        } else {
 728          msg.should.eql({
 729              type: 'json'
 730            , data: 123
 731            , endpoint: ''
 732          });
 733
 734          messages++;
 735        }
 736      });
 737
 738      setTimeout(function () {
 739        ws1.finishClose();
 740      }, 50);
 741    });
 742
 743    cl2.handshake(function (sid) {
 744      var ws2 = websocket(cl2, sid);
 745      ws2.on('message', function (msg) {
 746        if (!ws2.connected) {
 747          msg.type.should.eql('connect');
 748          ws2.connected = true;
 749        } else {
 750          msg.should.eql({
 751              type: 'json'
 752            , data: 123
 753            , endpoint: ''
 754          });
 755
 756          messages++;
 757        }
 758      });
 759
 760      setTimeout(function () {
 761        ws2.finishClose();
 762      }, 50);
 763    });
 764
 765    cl3.handshake(function (sid) {
 766      var ws3 = websocket(cl3, sid);
 767      ws3.on('message', function (msg) {
 768        if (!ws3.connected) {
 769          msg.type.should.eql('connect');
 770          ws3.connected = true;
 771        } else {
 772          msg.should.eql({
 773              type: 'json'
 774            , data: 123
 775            , endpoint: ''
 776          });
 777
 778          messages++;
 779        }
 780      });
 781
 782      setTimeout(function () {
 783        ws3.finishClose();
 784      }, 50);
 785    });
 786  },
 787
 788  'test emitting to all clients in a room': function (done) {
 789    var port = ++ports
 790      , cl1 = client(port)
 791      , cl2 = client(port)
 792      , cl3 = client(port)
 793      , io = create(cl1)
 794      , messages = 0
 795      , joins = 0
 796      , connections = 0
 797      , disconnections = 0;
 798
 799    io.configure(function () {
 800      io.set('close timeout', 0);
 801    });
 802
 803    io.sockets.on('connection', function (socket) {
 804      connections++;
 805
 806      if (connections != 3) {
 807        socket.join('woot');
 808        joins++;
 809
 810        if (joins == 2) {
 811          setTimeout(function () {
 812            connections.should.eql(3);
 813            io.sockets.in('woot').emit('locki');
 814          }, 20);
 815        }
 816      }
 817
 818      socket.on('disconnect', function () {
 819        disconnections++;
 820
 821        if (disconnections == 3) {
 822          messages.should.eql(2);
 823          cl1.end();
 824          cl2.end();
 825          cl3.end();
 826          io.server.close();
 827          done();
 828        }
 829      });
 830    });
 831
 832    cl1.handshake(function (sid) {
 833      var ws1 = websocket(cl1, sid);
 834      ws1.on('message', function (msg) {
 835        if (!ws1.connected) {
 836          msg.type.should.eql('connect');
 837          ws1.connected = true;
 838        } else {
 839          msg.should.eql({
 840              type: 'event'
 841            , name: 'locki'
 842            , args: []
 843            , endpoint: ''
 844          });
 845
 846          messages++;
 847        }
 848      });
 849
 850      setTimeout(function () {
 851        ws1.finishClose();
 852      }, 50);
 853    });
 854
 855    cl2.handshake(function (sid) {
 856      var ws2 = websocket(cl2, sid);
 857      ws2.on('message', function (msg) {
 858        if (!ws2.connected) {
 859          msg.type.should.eql('connect');
 860          ws2.connected = true;
 861        } else {
 862          msg.should.eql({
 863              type: 'event'
 864            , name: 'locki'
 865            , args: []
 866            , endpoint: ''
 867          });
 868
 869          messages++;
 870        }
 871      });
 872
 873      setTimeout(function () {
 874        ws2.finishClose();
 875      }, 50);
 876    });
 877
 878    cl3.handshake(function (sid) {
 879      var ws3 = websocket(cl3, sid);
 880      ws3.on('message', function (msg) {
 881        if (!ws3.connected) {
 882          msg.type.should.eql('connect');
 883          ws3.connected = true;
 884        } else {
 885          msg.should.eql({
 886              type: 'event'
 887            , name: 'locki'
 888            , args: []
 889            , endpoint: ''
 890          });
 891
 892          messages++;
 893        }
 894      });
 895
 896      setTimeout(function () {
 897        ws3.finishClose();
 898      }, 50);
 899    });
 900  },
 901
 902  'test leaving a room': function (done) {
 903    var port = ++ports
 904      , cl1 = client(port)
 905      , cl2 = client(port)
 906      , io = create(cl1)
 907      , joins = 0
 908      , disconnects = 0;
 909
 910    io.set('close timeout', 0);
 911
 912    io.sockets.on('connection', function (socket) {
 913      socket.join('foo');
 914      io.sockets.clients('foo').should.have.length(++joins);
 915
 916      socket.on('disconnect', function () {
 917        socket.leave('foo');
 918        socket.leave('foo');
 919        socket.leave('foo');
 920
 921        io.sockets.clients('foo').should.have.length(--joins);
 922
 923        if (++disconnects == 2) {
 924          io.server.close();
 925          cl1.end();
 926          cl2.end();
 927          done();
 928        }
 929      })
 930    });
 931
 932    cl1.handshake(function (sid) {
 933      var ws1 = websocket(cl1, sid);
 934      ws1.on('message', function (msg) {
 935        if (!ws1.connected) {
 936          msg.type.should.eql('connect');
 937          ws1.connected = true;
 938           ws1.finishClose();
 939        }
 940      });
 941    });
 942
 943    cl2.handshake(function (sid) {
 944      var ws2 = websocket(cl2, sid);
 945      ws2.on('message', function (msg) {
 946        if (!ws2.connected) {
 947          msg.type.should.eql('connect');
 948          ws2.connected = true;
 949          ws2.finishClose();
 950        }
 951      });
 952    });
 953  },
 954
 955  'test message with broadcast flag': function (done) {
 956    var port = ++ports
 957      , cl1 = client(port)
 958      , cl2 = client(port)
 959      , cl3 = client(port)
 960      , io = create(cl1)
 961      , messages = 0
 962      , disconnections = 0;
 963
 964    io.configure(function () {
 965      io.set('close timeout', 0);
 966    });
 967
 968    io.sockets.on('connection', function (socket) {
 969      socket.on('trigger broadcast', function () {
 970        socket.broadcast.send('boom');
 971      });
 972
 973      socket.on('disconnect', function () {
 974        disconnections++;
 975
 976        if (disconnections == 3) {
 977          messages.should.eql(2);
 978          cl1.end();
 979          cl2.end();
 980          cl3.end();
 981          io.server.close();
 982          done();
 983        }
 984      });
 985    });
 986
 987    cl1.handshake(function (sid) {
 988      var ws1 = websocket(cl1, sid);
 989      ws1.on('message', function (msg) {
 990        if (!ws1.connected) {
 991          msg.type.should.eql('connect');
 992          ws1.connected = true;
 993        } else {
 994          msg.should.eql({
 995              type: 'message'
 996            , data: 'boom'
 997            , endpoint: ''
 998          });
 999
1000          messages++;
1001          ws1.finishClose();
1002        }
1003      });
1004    });
1005
1006    cl2.handshake(function (sid) {
1007      var ws2 = websocket(cl2, sid);
1008      ws2.on('message', function (msg) {
1009        if (!ws2.connected) {
1010          msg.type.should.eql('connect');
1011          ws2.connected = true;
1012        } else {
1013          msg.should.eql({
1014              type: 'message'
1015            , data: 'boom'
1016            , endpoint: ''
1017          });
1018
1019          messages++;
1020          ws2.finishClose();
1021        }
1022      });
1023    });
1024
1025    cl3.handshake(function (sid) {
1026      var ws3 = websocket(cl3, sid);
1027      ws3.on('open', function () {
1028        ws3.packet({
1029            type: 'event'
1030          , name: 'trigger broadcast'
1031          , endpoint: ''
1032        });
1033
1034        setTimeout(function () {
1035          ws3.finishClose();
1036        }, 50);
1037      });
1038
1039      ws3.on('message', function (msg) {
1040        if (!ws3.connected) {
1041          msg.type.should.eql('connect');
1042          ws3.connected = true;
1043        } else {
1044          throw new Error('we shouldnt get a message here');
1045        }
1046      });
1047    });
1048  },
1049
1050  'test json with broadcast flag': function (done) {
1051    var port = ++ports
1052      , cl1 = client(port)
1053      , cl2 = client(port)
1054      , cl3 = client(port)
1055      , io = create(cl1)
1056      , messages = 0
1057      , disconnections = 0;
1058
1059    io.configure(function () {
1060      io.set('close timeout', 0);
1061    });
1062
1063    io.sockets.on('connection', function (socket) {
1064      socket.on('trigger broadcast', function () {
1065        socket.broadcast.json.send([1, 2, 3]);
1066      });
1067
1068      socket.on('disconnect', function () {
1069        disconnections++;
1070
1071        if (disconnections == 3) {
1072          messages.should.eql(2);
1073          cl1.end();
1074          cl2.end();
1075          cl3.end();
1076          io.server.close();
1077          done();
1078        }
1079      });
1080    });
1081
1082    cl1.handshake(function (sid) {
1083      var ws1 = websocket(cl1, sid);
1084      ws1.on('message', function (msg) {
1085        if (!ws1.connected) {
1086          msg.type.should.eql('connect');
1087          ws1.connected = true;
1088        } else {
1089          msg.should.eql({
1090              type: 'json'
1091            , data: [1, 2, 3]
1092            , endpoint: ''
1093          });
1094
1095          messages++;
1096          ws1.finishClose();
1097        }
1098      });
1099    });
1100
1101    cl2.handshake(function (sid) {
1102      var ws2 = websocket(cl2, sid);
1103      ws2.on('message', function (msg) {
1104        if (!ws2.connected) {
1105          msg.type.should.eql('connect');
1106          ws2.connected = true;
1107        } else {
1108          msg.should.eql({
1109              type: 'json'
1110            , data: [1, 2, 3]
1111            , endpoint: ''
1112          });
1113
1114          messages++;
1115          ws2.finishClose();
1116        }
1117      });
1118    });
1119
1120    cl3.handshake(function (sid) {
1121      var ws3 = websocket(cl3, sid);
1122      ws3.on('open', function () {
1123        ws3.packet({
1124            type: 'event'
1125          , name: 'trigger broadcast'
1126          , endpoint: ''
1127        });
1128
1129        setTimeout(function () {
1130          ws3.finishClose();
1131        }, 50);
1132      });
1133
1134      ws3.on('message', function (msg) {
1135        if (!ws3.connected) {
1136          msg.type.should.eql('connect');
1137          ws3.connected = true;
1138        } else {
1139          throw new Error('we shouldnt get a message here');
1140        }
1141      });
1142    });
1143  },
1144
1145  'test event with broadcast flag': function (done) {
1146    var port = ++ports
1147      , cl1 = client(port)
1148      , cl2 = client(port)
1149      , cl3 = client(port)
1150      , io = create(cl1)
1151      , messages = 0
1152      , disconnections = 0;
1153
1154    io.configure(function () {
1155      io.set('close timeout', 0);
1156    });
1157
1158    io.sockets.on('connection', function (socket) {
1159      socket.on('trigger broadcast', function () {
1160        socket.broadcast.emit('hey', 'arnold');
1161      });
1162
1163      socket.on('disconnect', function () {
1164        disconnections++;
1165
1166        if (disconnections == 3) {
1167          messages.should.eql(2);
1168          cl1.end();
1169          cl2.end();
1170          cl3.end();
1171          io.server.close();
1172          done();
1173        }
1174      });
1175    });
1176
1177    cl1.handshake(function (sid) {
1178      var ws1 = websocket(cl1, sid);
1179      ws1.on('message', function (msg) {
1180        if (!ws1.connected) {
1181          msg.type.should.eql('connect');
1182          ws1.connected = true;
1183        } else {
1184          msg.should.eql({
1185              type: 'event'
1186            , name: 'hey'
1187            , args: ['arnold']
1188            , endpoint: ''
1189          });
1190
1191          messages++;
1192          ws1.finishClose();
1193        }
1194      });
1195    });
1196
1197    cl2.handshake(function (sid) {
1198      var ws2 = websocket(cl2, sid);
1199      ws2.on('message', function (msg) {
1200        if (!ws2.connected) {
1201          msg.type.should.eql('connect');
1202          ws2.connected = true;
1203        } else {
1204          msg.should.eql({
1205              type: 'event'
1206            , name: 'hey'
1207            , args: ['arnold']
1208            , endpoint: ''
1209          });
1210
1211          messages++;
1212          ws2.finishClose();
1213        }
1214      });
1215    });
1216
1217    cl3.handshake(function (sid) {
1218      var ws3 = websocket(cl3, sid);
1219      ws3.on('open', function () {
1220        ws3.packet({
1221            type: 'event'
1222          , name: 'trigger broadcast'
1223          , endpoint: ''
1224        });
1225
1226        setTimeout(function () {
1227          ws3.finishClose();
1228        }, 50);
1229      });
1230
1231      ws3.on('message', function (msg) {
1232        if (!ws3.connected) {
1233          msg.type.should.eql('connect');
1234          ws3.connected = true;
1235        } else {
1236          throw new Error('we shouldnt get a message here');
1237        }
1238      });
1239    });
1240  },
1241
1242  'test message with broadcast flag and to()': function (done) {
1243    var port = ++ports
1244      , cl1 = client(port)
1245      , cl2 = client(port)
1246      , cl3 = client(port)
1247      , io = create(cl1)
1248      , messages = 0
1249      , connections = 0
1250      , disconnections = 0;
1251
1252    io.configure(function () {
1253      io.set('close timeout', 0);
1254    });
1255
1256    io.sockets.on('connection', function (socket) {
1257      connections++;
1258
1259      if (connections == 1) {
1260        socket.join('losers');
1261      }
1262
1263      socket.on('trigger broadcast', function () {
1264        socket.broadcast.to('losers').send('boom');
1265      });
1266
1267      socket.on('disconnect', function () {
1268        disconnections++;
1269
1270        if (disconnections == 3) {
1271          messages.should.eql(1);
1272          cl1.end();
1273          cl2.end();
1274          cl3.end();
1275          io.server.close();
1276          done();
1277        }
1278      });
1279    });
1280
1281    cl1.handshake(function (sid) {
1282      var ws1 = websocket(cl1, sid);
1283      ws1.on('message', function (msg) {
1284        if (!ws1.connected) {
1285          msg.type.should.eql('connect');
1286          ws1.connected = true;
1287        } else {
1288          msg.should.eql({
1289              type: 'message'
1290            , data: 'boom'
1291            , endpoint: ''
1292          });
1293
1294          messages++;
1295        }
1296      });
1297
1298      ws1.on('open', function () {
1299        cl2.handshake(function (sid) {
1300          var ws2 = websocket(cl2, sid);
1301          ws2.on('message', function (msg) {
1302            if (!ws2.connected) {
1303              msg.type.should.eql('connect');
1304              ws2.connected = true;
1305            } else {
1306              throw new Error('This socket shouldnt get a message');
1307            }
1308          });
1309
1310          ws2.on('open', function () {
1311            cl3.handshake(function (sid) {
1312              var ws3 = websocket(cl3, sid);
1313              ws3.on('open', function () {
1314                ws3.packet({
1315                    type: 'event'
1316                  , name: 'trigger broadcast'
1317                  , endpoint: ''
1318                });
1319
1320                setTimeout(function () {
1321                  ws1.finishClose();
1322                  ws2.finishClose();
1323                  ws3.finishClose();
1324                }, 50);
1325              });
1326
1327              ws3.on('message', function (msg) {
1328                if (!ws3.connected) {
1329                  msg.type.should.eql('connect');
1330                  ws3.connected = true;
1331                } else {
1332                  throw new Error('we shouldnt get a message here');
1333                }
1334              });
1335            });
1336          });
1337        });
1338      });
1339    });
1340  },
1341
1342  'test json with broadcast flag and to()': function (done) {
1343    var port = ++ports
1344      , cl1 = client(port)
1345      , cl2 = client(port)
1346      , cl3 = client(port)
1347      , io = create(cl1)
1348      , messages = 0
1349      , connections = 0
1350      , disconnections = 0;
1351
1352    io.configure(function () {
1353      io.set('close timeout', 0);
1354    });
1355
1356    io.sockets.on('connection', function (socket) {
1357      connections++;
1358
1359      if (connections == 1) {
1360        socket.join('losers');
1361      }
1362
1363      socket.on('trigger broadcast', function () {
1364        socket.broadcast.json.to('losers').send({ hello: 'world' });
1365      });
1366
1367      socket.on('disconnect', function () {
1368        disconnections++;
1369
1370        if (disconnections == 3) {
1371          messages.should.eql(1);
1372          cl1.end();
1373          cl2.end();
1374          cl3.end();
1375          io.server.close();
1376          done();
1377        }
1378      });
1379    });
1380
1381    cl1.handshake(function (sid) {
1382      var ws1 = websocket(cl1, sid);
1383      ws1.on('message', function (msg) {
1384        if (!ws1.connected) {
1385          msg.type.should.eql('connect');
1386          ws1.connected = true;
1387        } else {
1388          msg.should.eql({
1389              type: 'json'
1390            , data: { hello: 'world' }
1391            , endpoint: ''
1392          });
1393
1394          messages++;
1395        }
1396      });
1397
1398      ws1.on('open', function () {
1399        cl2.handshake(function (sid) {
1400          var ws2 = websocket(cl2, sid);
1401          ws2.on('message', function (msg) {
1402            if (!ws2.connected) {
1403              msg.type.should.eql('connect');
1404              ws2.connected = true;
1405            } else {
1406              throw new Error('This socket shouldnt get a message');
1407            }
1408          });
1409
1410          ws2.on('open', function () {
1411            cl3.handshake(function (sid) {
1412              var ws3 = websocket(cl3, sid);
1413              ws3.on('open', function () {
1414                ws3.packet({
1415                    type: 'event'
1416                  , name: 'trigger broadcast'
1417                  , endpoint: ''
1418                });
1419
1420                setTimeout(function () {
1421                  ws1.finishClose();
1422                  ws2.finishClose();
1423                  ws3.finishClose();
1424                }, 50);
1425              });
1426
1427              ws3.on('message', function (msg) {
1428                if (!ws3.connected) {
1429                  msg.type.should.eql('connect');
1430                  ws3.connected = true;
1431                } else {
1432                  throw new Error('we shouldnt get a message here');
1433                }
1434              });
1435            });
1436          });
1437        });
1438      });
1439    });
1440  },
1441
1442  'test event with broadcast flag and to()': function (done) {
1443    var port = ++ports
1444      , cl1 = client(port)
1445      , cl2 = client(port)
1446      , cl3 = client(port)
1447      , io = create(cl1)
1448      , messages = 0
1449      , connections = 0
1450      , disconnections = 0;
1451
1452    io.configure(function () {
1453      io.set('close timeout', 0);
1454    });
1455
1456    io.sockets.on('connection', function (socket) {
1457      connections++;
1458
1459      if (connections == 1) {
1460        socket.join('losers');
1461      }
1462
1463      socket.on('trigger broadcast', function () {
1464        socket.broadcast.to('losers').emit('victory');
1465      });
1466
1467      socket.on('disconnect', function () {
1468        disconnections++;
1469
1470        if (disconnections == 3) {
1471          messages.should.eql(1);
1472          cl1.end();
1473          cl2.end();
1474          cl3.end();
1475          io.server.close();
1476          done();
1477        }
1478      });
1479    });
1480
1481    cl1.handshake(function (sid) {
1482      var ws1 = websocket(cl1, sid);
1483      ws1.on('message', function (msg) {
1484        if (!ws1.connected) {
1485          msg.type.should.eql('connect');
1486          ws1.connected = true;
1487        } else {
1488          msg.should.eql({
1489              type: 'event'
1490            , name: 'victory'
1491            , args: []
1492            , endpoint: ''
1493          });
1494
1495          messages++;
1496        }
1497      });
1498
1499      ws1.on('open', function () {
1500        cl2.handshake(function (sid) {
1501          var ws2 = websocket(cl2, sid);
1502          ws2.on('message', function (msg) {
1503            if (!ws2.connected) {
1504              msg.type.should.eql('connect');
1505              ws2.connected = true;
1506            } else {
1507              throw new Error('This socket shouldnt get a message');
1508            };
1509          });
1510
1511          ws2.on('open', function () {
1512            cl3.handshake(function (sid) {
1513              var ws3 = websocket(cl3, sid);
1514              ws3.on('open', function () {
1515                ws3.packet({
1516                    type: 'event'
1517                  , name: 'trigger broadcast'
1518                  , endpoint: ''
1519                });
1520
1521                setTimeout(function () {
1522                  ws1.finishClose();
1523                  ws2.finishClose();
1524                  ws3.finishClose();
1525                }, 50);
1526              });
1527
1528              ws3.on('message', function (msg) {
1529                if (!ws3.connected) {
1530                  msg.type.should.eql('connect');
1531                  ws3.connected = true;
1532                } else {
1533                  throw new Error('we shouldnt get a message here');
1534                }
1535              });
1536            });
1537          });
1538        });
1539      });
1540    });
1541  },
1542
1543  'test accessing handshake data from sockets': function (done) {
1544    var cl = client(++ports)
1545      , io = create(cl)
1546      , ws;
1547
1548    io.sockets.on('connection', function (socket) {
1549      (!!socket.handshake.address.address).should.be.true;
1550      (!!socket.handshake.address.port).should.be.true;
1551      socket.handshake.headers.host.should.equal('localhost');
1552      socket.handshake.headers.connection.should.equal('keep-alive');
1553      socket.handshake.time.should.match(/GMT/);
1554
1555      socket.on('disconnect', function () {
1556        setTimeout(function () {
1557          ws.finishClose();
1558          cl.end();
1559          io.server.close();
1560          done();
1561        }, 10);
1562      });
1563
1564      socket.disconnect();
1565    });
1566
1567    cl.handshake(function (sid) {
1568      ws = websocket(cl, sid);
1569      ws.on('message', function (msg) {
1570        if (!ws.connected) {
1571          msg.type.should.eql('connect');
1572          ws.connected = true;
1573        }
1574      });
1575    });
1576  },
1577
1578  'test accessing the array of clients': function (done) {
1579    var port = ++ports
1580      , cl1 = client(port)
1581      , cl2 = client(port)
1582      , io = create(cl1)
1583      , total = 2
1584      , ws1, ws2;
1585
1586    io.sockets.on('connection', function (socket) {
1587      socket.on('join ferrets', function () {
1588        socket.join('ferrets');
1589        socket.send('done');
1590      });
1591    });
1592
1593    function check() {
1594      io.sockets.clients('ferrets').should.have.length(1);
1595      io.sockets.clients('ferrets')[0].should.be.an.instanceof(sio.Socket);
1596      io.sockets.clients('ferrets')[0].id.should.equal(ws1.sid);
1597      io.sockets.clients().should.have.length(2);
1598      io.sockets.clients()[0].should.be.an.instanceof(sio.Socket);
1599      io.sockets.clients()[0].id.should.equal(ws1.sid);
1600      io.sockets.clients()[1].should.be.an.instanceof(sio.Socket);
1601      io.sockets.clients()[1].id.should.equal(ws2.sid);
1602
1603      ws1.finishClose();
1604      ws2.finishClose();
1605      cl1.end();
1606      cl2.end();
1607      io.server.close();
1608      done();
1609    };
1610
1611    cl1.handshake(function (sid) {
1612      ws1 = websocket(cl1, sid);
1613      ws1.sid = sid;
1614      ws1.on('message', function (msg) {
1615        if (!ws1.connected) {
1616          msg.type.should.eql('connect');
1617          ws1.connected = true;
1618          ws1.packet({
1619              type: 'event'
1620            , name: 'join ferrets'
1621            , endpoint: ''
1622          });
1623        } else {
1624          cl2.handshake(function (sid) {
1625            ws2 = websocket(cl2, sid);
1626            ws2.sid = sid;
1627            ws2.on('message', function (msg) {
1628              if (!ws2.connected) {
1629                msg.type.should.eql('connect');
1630                ws2.connected = true;
1631                check();
1632              }
1633            });
1634          });
1635        }
1636      });
1637    });
1638  },
1639
1640  'test accessing handshake data from sockets on disconnect': function (done) {
1641    var cl = client(++ports)
1642      , io = create(cl)
1643      , ws;
1644
1645    io.sockets.on('connection', function (socket) {
1646      socket.on('disconnect', function () {
1647
1648      (!!socket.handshake.address.address).should.be.true;
1649      (!!socket.handshake.address.port).should.be.true;
1650      socket.handshake.headers.host.should.equal('localhost');
1651      socket.handshake.headers.connection.should.equal('keep-alive');
1652      socket.handshake.time.should.match(/GMT/);
1653
1654        setTimeout(function () {
1655          ws.finishClose();
1656          cl.end();
1657          io.server.close();
1658          done();
1659        }, 10);
1660      });
1661
1662      socket.disconnect();
1663    });
1664
1665    cl.handshake(function (sid) {
1666      ws = websocket(cl, sid);
1667      ws.on('message', function (msg) {
1668        if (!ws.connected) {
1669          msg.type.should.eql('connect');
1670          ws.connected = true;
1671        }
1672      });
1673    });
1674  },
1675
1676  'test for intentional and unintentional disconnects': function (done) {
1677    var cl = client(++ports)
1678      , io = create(cl)
1679      , calls = 0
1680      , ws;
1681
1682    function close () {
1683      cl.end();
1684      io.server.close();
1685      ws.finishClose();
1686      done();
1687    }
1688
1689    io.configure(function () {
1690      io.set('heartbeat interval', .05);
1691      io.set('heartbeat timeout', .05);
1692      io.set('close timeout', 0);
1693    });
1694
1695    io.of('/foo').on('connection', function (socket) {
1696      socket.on('disconnect', function (reason) {
1697       reason.should.equal('packet');
1698
1699       if (++calls == 2) close();
1700      });
1701    });
1702
1703    io.of('/bar').on('connection', function (socket) {
1704      socket.on('disconnect', function (reason) {
1705        reason.should.equal('socket end');
1706
1707        if (++calls == 2) close();
1708      });
1709    });
1710
1711    cl.handshake(function (sid) {
1712      var messages = 0;
1713      ws = websocket(cl, sid);
1714      ws.on('open', function () {
1715        ws.packet({
1716            type: 'connect'
1717          , endpoint: '/foo'
1718        });
1719        ws.packet({
1720            type: 'connect'
1721          , endpoint: '/bar'
1722        });
1723      });
1724
1725      ws.on('message', function (packet) {
1726        if (packet.type == 'connect') {
1727          if (++messages === 3) {
1728            ws.packet({ type: 'disconnect', endpoint:'/foo' });
1729            ws.finishClose();
1730          }
1731        }
1732      });
1733    });
1734  },
1735
1736  'test socket clean up': function (done) {
1737    var cl = client(++ports)
1738      , io = create(cl)
1739      , ws;
1740
1741    io.sockets.on('connection', function (socket) {
1742      var self = this
1743        , id = socket.id;
1744
1745      socket.on('disconnect', function () {
1746        setTimeout(function () {
1747          var available = !!self.sockets[id];
1748
1749          available.should.be.false;
1750          ws.finishClose();
1751          cl.end();
1752          io.server.close();
1753          done();
1754        }, 10);
1755      });
1756
1757      socket.disconnect();
1758    });
1759
1760    cl.handshake(function (sid) {
1761      ws = websocket(cl, sid);
1762      ws.on('message', function (msg) {
1763        if (!ws.connected) {
1764          msg.type.should.eql('connect');
1765          ws.connected = true;
1766        }
1767      });
1768    });
1769  },
1770
1771};