github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/public/libs/sockjs-client-1.1.0/tests/lib/receivers.js (about)

     1  'use strict';
     2  
     3  var expect = require('expect.js')
     4    , JsonpReceiver = require('../../lib/transport/receiver/jsonp')
     5    , XhrReceiver = require('../../lib/transport/receiver/xhr')
     6    , XhrFake = require('../../lib/transport/sender/xhr-fake')
     7    , utils = require('../../lib/utils/iframe')
     8    ;
     9  
    10  describe('Receivers', function () {
    11    describe('jsonp', function () {
    12      var oldTimeout = JsonpReceiver.timeout;
    13      var oldScriptTimeout = JsonpReceiver.scriptErrorTimeout;
    14      var scriptFunc = JsonpReceiver.prototype._createScript;
    15      before(function () {
    16        JsonpReceiver.prototype._createScript = function () {};
    17        JsonpReceiver.timeout = 300;
    18      });
    19      after(function () {
    20        JsonpReceiver.timeout = oldTimeout;
    21        JsonpReceiver.scriptErrorTimeout = oldScriptTimeout;
    22        JsonpReceiver.prototype._createScript = scriptFunc;
    23      });
    24  
    25      it('receives data', function (done) {
    26        var test = this.runnable();
    27        JsonpReceiver.prototype._createScript = function () {
    28          var self = this;
    29          setTimeout(function () {
    30            global[utils.WPrefix][self.id]('datadata');
    31          }, 5);
    32        };
    33        var jpr = new JsonpReceiver('test');
    34        jpr.on('close', function (code, reason) {
    35          if (test.timedOut || test.duration) {
    36            return;
    37          }
    38  
    39          try {
    40            expect(reason).to.equal('network');
    41          } catch (e) {
    42            done(e);
    43            return;
    44          }
    45          done();
    46        });
    47        jpr.on('message', function (msg) {
    48          try {
    49            expect(msg).to.equal('datadata');
    50          } catch (e) {
    51            done(e);
    52            jpr.abort();
    53            return;
    54          }
    55        });
    56      });
    57  
    58      it('will timeout', function (done) {
    59        this.timeout(500);
    60        var test = this.runnable();
    61        JsonpReceiver.prototype._createScript = function () {
    62          var self = this;
    63          setTimeout(function () {
    64            if (global[utils.WPrefix][self.id]) {
    65              global[utils.WPrefix][self.id]('datadata');
    66            }
    67          }, 400);
    68        };
    69  
    70        var jpr = new JsonpReceiver('test');
    71        jpr.on('close', function (code, reason) {
    72          if (test.timedOut || test.duration) {
    73            return;
    74          }
    75  
    76          try {
    77            expect(reason).to.contain('timeout');
    78          } catch (e) {
    79            done(e);
    80            return;
    81          }
    82          done();
    83        });
    84        jpr.on('message', function () {
    85          done(new Error('No message should be sent'));
    86          jpr.abort();
    87        });
    88      });
    89  
    90      it('aborts without sending a message', function (done) {
    91        var test = this.runnable();
    92        JsonpReceiver.prototype._createScript = function () {
    93          var self = this;
    94          setTimeout(function () {
    95            if (global[utils.WPrefix][self.id]) {
    96              global[utils.WPrefix][self.id]('datadata');
    97            }
    98          }, 200);
    99        };
   100        var jpr = new JsonpReceiver('test');
   101        jpr.on('close', function (code, reason) {
   102          if (test.timedOut || test.duration) {
   103            return;
   104          }
   105  
   106          try {
   107            expect(reason).to.contain('aborted');
   108          } catch (e) {
   109            done(e);
   110            return;
   111          }
   112          done();
   113        });
   114        jpr.on('message', function () {
   115          done(new Error('No message should be sent'));
   116          jpr.abort();
   117        });
   118        jpr.abort();
   119      });
   120  
   121      it('will not report error if onerror triggered right before onreadystatechange (IE9)', function (done) {
   122        JsonpReceiver.scriptErrorTimeout = 300;
   123        var test = this.runnable();
   124        JsonpReceiver.prototype._createScript = function () {
   125          var self = this;
   126          // simulate a normal JSONP response
   127          setTimeout(function () {
   128            self.loadedOkay = true;
   129            global[utils.WPrefix][self.id]('datadata');
   130          }, 200);
   131        };
   132  
   133        var jpr = new JsonpReceiver('test');
   134        jpr.on('close', function (code, reason) {
   135          if (test.timedOut || test.duration) {
   136            return;
   137          }
   138          try {
   139            expect(reason).to.equal('network');
   140          } catch (e) {
   141            done(e);
   142            return;
   143          }
   144          done();
   145        });
   146        jpr.on('message', function (msg) {
   147          try {
   148            expect(msg).to.equal('datadata');
   149          } catch (e) {
   150            done(e);
   151            jpr.abort();
   152          }
   153        });
   154  
   155        // simulate script error
   156        jpr._scriptError();
   157      });
   158  
   159      it('will not report error if onerror triggered right after onreadystatechange (IE9)', function (done) {
   160        JsonpReceiver.scriptErrorTimeout = 100;
   161        var test = this.runnable();
   162        JsonpReceiver.prototype._createScript = function () {
   163          var self = this;
   164          // simulate a normal JSONP response
   165          setTimeout(function () {
   166            self.loadedOkay = true;
   167            global[utils.WPrefix][self.id]('datadata');
   168          }, 100);
   169        };
   170  
   171        var jpr = new JsonpReceiver('test');
   172        jpr.on('close', function (code, reason) {
   173          if (test.timedOut || test.duration) {
   174            return;
   175          }
   176          try {
   177            expect(reason).to.equal('network');
   178          } catch (e) {
   179            done(e);
   180            return;
   181          }
   182          done();
   183        });
   184        jpr.on('message', function (msg) {
   185          try {
   186            expect(msg).to.equal('datadata');
   187          } catch (e) {
   188            done(e);
   189            jpr.abort();
   190          }
   191        });
   192  
   193        // simulate script error
   194        setTimeout(function () {
   195          jpr._scriptError();
   196        }, 200);
   197      });
   198    });
   199  
   200    describe('xhr', function () {
   201      var oldTimeout;
   202      before(function () {
   203        oldTimeout = XhrFake.timeout;
   204        XhrFake.timeout = 100;
   205      });
   206      after(function () {
   207        XhrFake.timeout = oldTimeout;
   208      });
   209  
   210      it('emits multiple messages for multi-line response', function (done) {
   211        var test = this.runnable();
   212        var xhr = new XhrReceiver('test', XhrFake);
   213        var i = 0, responses = ['test', 'multiple', 'lines', '{}'];
   214        xhr.on('message', function (msg) {
   215          try {
   216            expect(msg).to.equal(responses[i]);
   217          } catch (e) {
   218            done(e);
   219            xhr.abort();
   220            return;
   221          }
   222          i++;
   223        });
   224        xhr.on('close', function (code, reason) {
   225          if (test.timedOut || test.duration) {
   226            return;
   227          }
   228          try {
   229            expect(reason).to.equal('network');
   230          } catch (e) {
   231            done(e);
   232            return;
   233          }
   234          done();
   235        });
   236        xhr._chunkHandler(200, 'test\nmultiple\nlines');
   237      });
   238  
   239      it('emits no messages for an empty string response', function (done) {
   240        var test = this.runnable();
   241        var xhr = new XhrReceiver('test', XhrFake);
   242        var i = 0, responses = ['{}'];
   243        xhr.on('message', function (msg) {
   244          try {
   245            expect(i).to.be.lessThan(responses.length);
   246            expect(msg).to.equal(responses[i]);
   247          } catch (e) {
   248            done(e);
   249            xhr.abort();
   250            return;
   251          }
   252          i++;
   253        });
   254        xhr.on('close', function (code, reason) {
   255          if (test.timedOut || test.duration) {
   256            return;
   257          }
   258          try {
   259            expect(reason).to.equal('network');
   260          } catch (e) {
   261            done(e);
   262            return;
   263          }
   264          done();
   265        });
   266        xhr._chunkHandler(200, '');
   267      });
   268  
   269      it('aborts without sending a message', function (done) {
   270        var test = this.runnable();
   271        var xhr = new XhrReceiver('test', XhrFake);
   272        xhr.on('message', function () {
   273          done(new Error());
   274          xhr.abort();
   275        });
   276        xhr.on('close', function (code, reason) {
   277          if (test.timedOut || test.duration) {
   278            return;
   279          }
   280          try {
   281            expect(reason).to.equal('user');
   282          } catch (e) {
   283            done(e);
   284            return;
   285          }
   286          done();
   287        });
   288        xhr.abort();
   289      });
   290    });
   291  });