coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/socket.io/tests/transports.websocket.js

@@ -0,0 +1,245 @@
+var io = require('socket.io')
+  , encode = require('socket.io/utils').encode
+  , decode = require('socket.io/utils').decode
+  , port = 7200
+  , Listener = io.Listener
+  , Client = require('socket.io/client')
+  , WebSocket = require('./../support/node-websocket-client/lib/websocket').WebSocket;
+
+function server(){
+  return require('http').createServer(function(){});
+};
+
+function socket(server, options){
+  if (!options) options = {};
+  options.log = false;
+  return io.listen(server, options);
+};
+
+function listen(s, callback){
+  s._port = port;
+  s.listen(port, callback);
+  port++;
+  return s;
+};
+
+function client(server, sessid){
+  sessid = sessid ? '/' + sessid : '';
+  return new WebSocket('ws://localhost:' + server._port + '/socket.io/websocket' + sessid, 'borf');
+};
+
+module.exports = {
+  
+  'test connection and handshake': function(assert){
+    var _server = server()
+      , _socket = socket(_server)
+      , _client
+      , trips = 2;
+    
+    function close(){
+      _client.close();
+      _server.close();
+    };
+    
+    listen(_server, function(){
+      var messages = 0;
+      _client = client(_server);
+      _client.onopen = function(){
+        _client.send(encode('from client'));
+      };
+      _client.onmessage = function(ev){
+        if (++messages == 2){ // first message is the session id
+          assert.ok(decode(ev.data), 'from server');
+          --trips || close();
+        }
+      };
+    });
+    
+    _socket.on('connection', function(conn){
+      assert.ok(conn instanceof Client);
+      conn
+        .on('message', function(msg){
+          assert.ok(msg == 'from client');
+          --trips || close();
+        })
+        .send('from server');
+    });
+  },
+  
+  'test clients tracking': function(assert){
+    var _server = server()
+      , _socket = socket(_server);
+      
+    listen(_server, function(){
+      var _client = client(_server);
+      _client.onopen = function(){
+        assert.ok(Object.keys(_socket.clients).length == 1);
+  
+        var _client2 = client(_server);
+        _client2.onopen = function(){
+          assert.ok(Object.keys(_socket.clients).length == 2);
+          
+          _client.close();
+          _client2.close();
+          _server.close();
+        };
+      }
+    });
+  },
+  
+  'test buffered messages': function(assert){
+    var _server = server()
+      , _socket = socket(_server, {
+          transportOptions: {
+            websocket: {
+              closeTimeout: 5000
+            }
+          }
+        });
+      
+    listen(_server, function(){
+      var _client = client(_server);
+      
+      _client.onopen = function(){
+        assert.ok(Object.keys(_socket.clients).length == 1);
+        var sessionid = Object.keys(_socket.clients)[0]
+          , runOnce = false;
+  
+        _socket.clients[sessionid].connection.addListener('end', function(){
+          if (!runOnce){
+            assert.ok(_socket.clients[sessionid]._open == false);
+            assert.ok(_socket.clients[sessionid].connected);
+            _socket.clients[sessionid].send('should get this');
+  
+            var _client2 = client(_server, sessionid);
+            _client2.onmessage = function(ev){
+              assert.ok(Object.keys(_socket.clients).length == 1);
+              assert.ok(decode(ev.data), 'should get this');
+              _socket.clients[sessionid].options.closeTimeout = 0;
+              _client2.close();
+              _server.close();
+            };
+            runOnce = true;
+          }
+        });
+        
+        _client.close();
+      };
+    });
+  },
+  
+  'test json encoding': function(assert){
+    var _server = server()
+      , _socket = socket(_server)
+      , _client
+      , trips = 2;
+    
+    function close(){
+      _server.close();
+      _client.close();
+    };
+    
+    listen(_server, function(){
+      _socket.on('connection', function(conn){
+        conn.on('message', function(msg){
+          assert.ok(msg.from == 'client');
+          --trips || close();
+        });
+        conn.send({ from: 'server' });
+      });
+      
+      var messages = 0;
+      
+      _client = client(_server);
+      _client.onmessage = function(ev){
+        if (++messages == 2){
+          assert.ok(decode(ev.data)[0].substr(0, 3) == '~j~');
+          assert.ok(JSON.parse(decode(ev.data)[0].substr(3)).from == 'server');
+          _client.send(encode({ from: 'client' }));
+          --trips || close();
+        }
+      };
+    });
+  },
+  
+  'test hearbeat timeout': function(assert){
+    var _server = server()
+      , _socket = socket(_server, {
+          transportOptions: {
+            websocket: {
+              timeout: 100,
+              heartbeatInterval: 1
+            }
+          }
+        });
+    
+    listen(_server, function(){
+      var _client = client(_server)
+        , messages = 0;
+      _client.onmessage = function(ev){
+        ++messages;
+        if (decode(ev.data)[0].substr(0, 3) == '~h~'){
+          assert.ok(messages === 2);
+          assert.ok(Object.keys(_socket.clients).length == 1);
+          setTimeout(function(){
+            assert.ok(Object.keys(_socket.clients).length == 0);
+            _client.close();
+            _server.close();
+          }, 150);
+        }
+      };
+    });
+  },
+  
+  'test client broadcast': function(assert){
+    var _server = server()
+      , _socket = socket(_server);
+    
+    listen(_server, function(){
+      var _client = client(_server)
+        , _client2
+        , _client3
+        , _first
+        , _connections = 0;
+        
+      _client.onmessage = function(ev){
+        if (!('messages' in _client)) _client.messages = 0;
+        if (++_client.messages == 2){
+          assert.ok(decode(ev.data)[0] == 'not broadcasted');
+          _client.close();
+          _client2.close();
+          _client3.close();
+          _server.close();
+        }
+      };
+      
+      _client.onopen = function(){
+        _client2 = client(_server);
+        _client2.onmessage = function(ev){
+          if (!('messages' in _client2)) _client2.messages = 0;
+          if (++_client2.messages == 2)
+            assert.ok(decode(ev.data)[0] == 'broadcasted')
+        };
+        _client2.onopen = function(){
+          _client3 = client(_server);
+          _client3.onmessage = function(ev){
+            if (!('messages' in _client3)) _client3.messages = 0;
+            if (++_client3.messages == 2)
+              assert.ok(decode(ev.data)[0] == 'broadcasted')
+          };
+        };
+      };
+      
+      _socket.on('connection', function(conn){
+        if (!_first)
+          _first = conn;
+        if (++_connections == 3){
+          _first.broadcast('broadcasted');
+          _first.send('not broadcasted');
+        }
+      });
+      
+    });
+  }
+  
+};

data/node_modules/jasmine-runner/node_modules/socket.io/tests/transports.xhr-multipart.js

@@ -0,0 +1,215 @@
+var io = require('socket.io')
+  , net = require('net')
+  , http = require('http')
+  , querystring = require('querystring')
+  , port = 7300
+  , encode = require('socket.io/utils').encode
+  , decode = require('socket.io/utils').decode
+  , EventEmitter = require('events').EventEmitter
+  , Multipart = require('socket.io/transports/xhr-multipart');
+  
+function server(callback){
+  return http.createServer(function(){});
+};
+
+function listen(s, callback){
+  s._port = port;
+  s.listen(port, callback);
+  port++;
+  return s;
+};
+
+function client(s){
+  return http.createClient(s._port, 'localhost');
+};
+
+function socket(server, options){
+  if (!options) options = {};
+  options.log = false;
+  if (!options.transportOptions) options.transportOptions = { 
+    'xhr-multipart': {
+      // disable heartbeats for tests, re-enabled in heartbeat test below
+      timeout: null 
+    }
+  };
+  return io.listen(server, options);
+};
+
+function get(server, url, callback){
+  var client = net.createConnection(server._port);
+  client.on('connect', function(){
+    client.write('GET ' + url + " HTTP/1.1\r\n\r\n");
+    
+    var resp = new EventEmitter()
+      , buffer = '';
+    
+    callback(resp);
+    client.on('data', function(_data){
+      var data = _data.toString()
+        , i = 0
+        , l = data.length;
+        
+      while (i < l){
+        // lookahead for the `--socketio\n` boundary
+        if (data.charAt(i) == '-' && data.substr(i, 11) == "--socketio\n"){
+          // header filtering
+          var filtered = buffer.replace(/[A-Z][^\n]+\r?\n?\n/gm, '')
+                               .replace(/^\r\n$/, '')
+                               .replace(/\n$/, '');
+          if (filtered !== '') resp.emit('data', filtered);
+          buffer = '';
+          i = i + 11;
+        } else {
+          buffer += data.charAt(i);
+          i++;
+        }
+      }
+    });
+  });
+  return client;
+};
+
+function post(client, url, data, callback){
+  var query = querystring.stringify(data)
+    , request = client.request('POST', url, {'Content-Length': Buffer.byteLength(query)});
+  request.write(query);
+  request.end();
+};
+
+module.exports = {
+  
+  'test connection and handshake': function(assert){
+    var _server = server()
+      , _socket = socket(_server)
+      , trips = 2;
+
+    listen(_server, function(){
+      var _client = get(_server, '/socket.io/xhr-multipart', function(response){
+        var i = 0;
+        response.on('data', function(data){
+          var msg = decode(data);
+          switch (i++){
+            case 0:
+              assert.ok(Object.keys(_socket.clients).length == 1);
+              assert.ok(msg == Object.keys(_socket.clients)[0]);
+              assert.ok(_socket.clients[msg] instanceof Multipart);
+              _socket.clients[msg].send('from server');
+              post(client(_server), '/socket.io/xhr-multipart/' + msg + '/send', {data: encode('from client')});
+              break;
+            case 1:
+              assert.ok(msg == 'from server');
+              --trips || close();
+          }
+        });
+      });
+      
+      _socket.on('connection', function(client){
+        assert.ok(client instanceof Multipart);
+        client.on('message', function(msg){
+          assert.ok(msg == 'from client');
+          --trips || close();
+        });
+      });
+      
+      function close(){
+        _client.end();
+        _server.close();
+      };
+    });
+  },
+  
+  'test clients tracking': function(assert){
+    var _server = server()
+      , _socket = socket(_server);
+    
+    listen(_server, function(){
+      var _client = get(_server, '/socket.io/xhr-multipart', function(response){
+        var once = false
+        response.on('data', function(){
+          if (!once){
+            assert.ok(Object.keys(_socket.clients).length == 1);
+            once = true;
+            var _client2 = get(_server, '/socket.io/xhr-multipart', function(response){
+              response.on('data', function(){
+                assert.ok(Object.keys(_socket.clients).length == 2);
+                _client.end();
+                _client2.end();
+                _server.close();
+              });
+            });
+          }
+        });
+      });
+    });
+  },
+  
+  'test buffered messages': function(assert){
+    var _server = server()
+      , _socket = socket(_server, { transportOptions: { 
+        'xhr-multipart': {
+          closeTimeout: 100
+        }
+      } });
+      
+    listen(_server, function(){
+      var _client = get(_server, '/socket.io/xhr-multipart', function(response){
+        var once = false;
+        response.on('data', function(data){
+          if (!once){
+            var sessid = decode(data);
+            assert.ok(_socket.clients[sessid]._open === true);
+            assert.ok(_socket.clients[sessid].connected);
+            
+            _socket.clients[sessid].connection.addListener('end', function(){
+              assert.ok(_socket.clients[sessid]._open === false);
+              assert.ok(_socket.clients[sessid].connected);
+              
+              _socket.clients[sessid].send('from server');
+              
+              _client = get(_server, '/socket.io/xhr-multipart/' + sessid, function(response){
+                response.on('data', function(data){
+                  assert.ok(decode(data) == 'from server');
+                  _client.end();
+                  _server.close();
+                });
+              });
+            });
+            _client.end();
+            once = true;
+          }
+        });
+      });
+    });
+  },
+  
+  'test hearbeat timeout': function(assert){
+    var _server = server()
+      , _socket = socket(_server, {
+          transportOptions: {
+            'xhr-multipart': {
+              timeout: 100,
+              heartbeatInterval: 1
+            }
+          }
+        });
+    listen(_server, function(){
+      var client = get(_server, '/socket.io/xhr-multipart', function(response){
+        var messages = 0;
+        response.on('data', function(data){
+          ++messages;
+          var msg = decode(data);
+          if (msg[0].substr(0, 3) == '~h~'){
+            assert.ok(messages == 2);
+            assert.ok(Object.keys(_socket.clients).length == 1);
+            setTimeout(function(){
+              assert.ok(Object.keys(_socket.clients).length == 0);
+              client.end();
+              _server.close();
+            }, 150);
+          }
+        });
+      });
+    });
+  }
+  
+};