vulcan 0.0.1 → 0.0.2

data/server/node_modules/connect-form/support/connect/test/providers/echo.js

@@ -0,0 +1,10 @@
+
+module.exports = function(){
+    return function(req, res, next){
+        res.writeHead(200, {
+            'Content-Type': 'text/plain',
+            'Conent-Length': req.body.length
+        })
+        res.end(req.body)
+    };
+};

data/server/node_modules/connect-form/support/connect/test/responseTime.test.js

@@ -0,0 +1,29 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+module.exports = {
+    test: function(){
+        var server = helpers.run(
+            connect.responseTime(),
+            function(req, res){
+                setTimeout(function(){
+                    res.writeHead(200, {});
+                    res.end();
+                }, 20);
+            }
+        );
+
+        var req = server.request('GET', '/');
+        req.addListener('response', function(res){
+            assert.ok(!isNaN(parseInt(res.headers['x-response-time'])), 'Test X-Response-Time header')
+        });
+        req.end();
+    }
+}

data/server/node_modules/connect-form/support/connect/test/router.test.js

@@ -0,0 +1,154 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+/**
+ * Path to ./test/fixtures/
+ */
+
+var fixturesPath = __dirname + '/fixtures';
+
+// Faux products app
+
+function products(app){
+    app.get('/.:format?', function(req, res, params){
+        res.writeHead(200, {});
+        res.end('products' + (params.format ? ' as ' + params.format : ''));
+    });
+    app.get('/:id', function(req, res, params){
+        res.writeHead(200, {});
+        res.end('product ' + params.id);
+    });
+}
+
+// Faux main app
+
+function main(app){
+    app.post('/', function(req, res){
+        res.writeHead(200, {});
+        res.end('POST /');
+    });
+    app.put('/', function(req, res){
+        res.writeHead(200, {});
+        res.end('PUT /');
+    });
+    app.del('/', function(req, res){
+        res.writeHead(200, {});
+        res.end('DELETE /');
+    });
+    app.get('/', function(req, res){
+        res.writeHead(200, {});
+        res.end('GET /');
+    });
+    app.get('/public/*', function(req, res, params){
+        res.writeHead(200, {});
+        res.end('splat "' + params.splat[0] + '"');
+    });
+    app.get('/files/*.*', function(req, res, params){
+        res.writeHead(200, {});
+        res.end('path: "' + params.splat[0] + '" ext: "' + params.splat[1] + '"');
+    });
+    app.get('/user/:id/:operation?', function(req, res, params){
+        res.writeHead(200, {});
+        res.end((params.operation || 'view') + 'ing user ' + req.params.path.id);
+    });
+    app.get('/range/:from-:to?', function(req, res, params){
+        res.writeHead(200, {});
+        res.end('range ' + params.from + ' to ' + (params.to || 'HEAD'));
+    });
+    app.get('/users.:format', function(req, res, params){
+        res.writeHead(200, {});
+        res.end(params.format + ' format');
+    });
+    app.get(/\/commit\/(\w+)\.\.(\w+)\/?/i, function(req, res, params){
+        res.writeHead(200, {});
+        res.end('captures: ' + params.splat.join(', '));
+    });
+    app.get('/next', function(req, res, params, next){
+        next();
+    });
+    app.get('/error', function(req, res, params, next){
+        throw new Error('boom!');
+    });
+    app.get('/cookies.:format?', function(req, res, params){
+        var cookies = ['num', 'num'];
+        res.writeHead(200, {});
+        switch (params.format) {
+            case 'json':
+                res.end(JSON.stringify(cookies));
+                break;
+            default:
+                res.end(cookies.join(' '));
+        }
+    });
+    app.get('/items/:id?', function(req, res, params, next){
+        if (params.id) {
+            res.writeHead(200, {});
+            res.end('item ' + params.id);
+        } else {
+            next();
+        }
+    });
+    app.get('/items', function(req, res, params, next){
+        next()
+    });
+    app.get('/items', function(req, res, params){
+        res.writeHead(200, {});
+        res.end('items');
+    });
+    app.get('/failure/:id?', function(req, res, params, next){
+        next(new Error('fail boat'));
+    });
+    app.get('/failure', function(req, res, params){
+        assert.fail('next(new Error) passed to next matching router callback');
+    });
+}
+
+module.exports = {
+    'test routing': function(){
+        var server = helpers.run();
+        server.use('/products', connect.router(products));
+        server.use('/', connect.router(main));
+        server.use('/', connect.errorHandler({ showMessage: true }));
+
+        server.assertResponse('GET', '/items/12', 200, 'item 12');
+        server.assertResponse('GET', '/items', 200, 'items');
+        
+        server.assertResponse('GET', '/failure/12', 500, 'Error: fail boat');
+        
+        server.assertResponse('GET', '/products', 200, 'products');
+        server.assertResponse('GET', '/products/', 200, 'products');
+        server.assertResponse('GET', '/products.json', 200, 'products as json');
+        server.assertResponse('GET', '/products/12', 200, 'product 12');
+        
+        server.assertResponse('GET', '/next', 404, 'Cannot GET /next');
+        server.assertResponse('GET', '/error', 500, 'Error: boom!');
+
+        server.assertResponse('GET', '/', 200, 'GET /', 'Test router GET /');
+        server.assertResponse('POST', '/', 200, 'POST /', 'Test router POST /');
+        server.assertResponse('PUT', '/', 200, 'PUT /', 'Test router PUT /');
+        server.assertResponse('DELETE', '/', 200, 'DELETE /', 'Test router DELETE /');
+        server.assertResponse('GET', '/user', 404, 'Cannot GET /user', 'Test router GET unmatched path param');
+        server.assertResponse('GET', '/user/12', 200, 'viewing user 12', 'Test router GET matched path param');
+        server.assertResponse('GET', '/user/12/', 200, 'viewing user 12', 'Test router GET matched path param with trailing slash');
+        server.assertResponse('GET', '/user/99/edit', 200, 'editing user 99', 'Test router GET matched path with several params');
+        server.assertResponse('GET', '/user/99/edit/', 200, 'editing user 99', 'Test router GET matched path with several params with trailing slash');
+        server.assertResponse('GET', '/range/11-99', 200, 'range 11 to 99');
+        server.assertResponse('GET', '/range/11-', 200, 'range 11 to HEAD');
+        server.assertResponse('GET', '/users.json', 200, 'json format');
+        server.assertResponse('GET', '/cookies', 200, 'num num', 'Test router optional placeholder without value');
+        server.assertResponse('GET', '/cookies.json', 200, '["num","num"]', 'Test reset optional placeholder with value');
+        server.assertResponse('GET', '/public', 404, 'Cannot GET /public', 'Test required splat without value');
+        server.assertResponse('GET', '/public/jquery.js', 200, 'splat "jquery.js"', 'Test required splat with value');
+        server.assertResponse('GET', '/public/javascripts/jquery.js', 200, 'splat "javascripts/jquery.js"', 'Test required splat with segmented');
+        server.assertResponse('GET', '/files/jquery.js', 200, 'path: "jquery" ext: "js"', 'Test several required splats');
+        server.assertResponse('GET', '/files/javascripts/jquery.js', 200, 'path: "javascripts/jquery" ext: "js"', 'Test several required splats');
+        server.assertResponse('GET', '/commit/foo..bar', 200, 'captures: foo, bar', 'Test RegExp paths');
+    }
+}

data/server/node_modules/connect-form/support/connect/test/session.test.js

@@ -0,0 +1,127 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+// Session
+
+var Session = require('connect/middleware/session/session');
+
+// Stores
+
+var MemoryStore = require('connect/middleware/session/memory');
+
+module.exports = {
+    'test MemoryStore': function(){
+        var n = 0, sid;
+        var server = helpers.run(
+            connect.cookieDecoder(),
+            connect.session({ store: new MemoryStore({ reapInterval: -1 }) }),
+            function(req, res, next){
+                assert.ok(req.sessionStore, 'Test req.sessionStore');
+                assert.ok(req.sessionHash, 'Test req.sessionHash');
+                switch (n++) {
+                    case 0:
+                        assert.eql(['id', 'lastAccess'], Object.keys(req.session),
+                            'Test MemoryStore session initialization');
+                        break;
+                    case 1:
+                        req.sessionStore.length(function(err, len){
+                            assert.equal(1, len, 'Test MemoryStore#length()');
+                        });
+                        assert.eql(['id', 'lastAccess'], Object.keys(req.session),
+                            'Test MemoryStore session initialization with invalid sid');
+                        assert.notEqual('123123', req.session.id, 'Test MemoryStore sid regeneration');
+                        break;
+                    case 2:
+                        lastAccess = req.session.lastAccess;
+                        break;
+                    case 3:
+                        assert.equal(sid, req.session.id, 'Test MemoryStore persistence');
+                        assert.notEqual(lastAccess, req.session.lastAccess, 'Test MemoryStore lastAccess update');
+                        break;
+                    case 4:
+                        assert.notEqual(sid, req.session.id, 'Test MemoryStore User-Agent fingerprint');
+                        break;
+                    case 5:
+                        req.sessionStore.destroy(req.sessionHash, function(err){
+                            assert.ok(!err, 'Test MemoryStore#destroy() when present');
+                        });
+                        break;
+                    case 6:
+                        req.sessionStore.destroy(req, function(err, destroyed){
+                            assert.ok(!err);
+                            assert.ok(!destroyed, 'Test MemoryStore#destroy()');
+                        });
+                        var sess = new Session(req, '12323');
+                        assert.eql(['id', 'lastAccess'], Object.keys(sess), 'Test new Session(req, sid)');
+                        assert.equal(req, sess.req, 'Test Session#req');
+                        
+                        var sess = new Session(req, { id: '12323', name: 'tj', lastAccess: +new Date });
+                        assert.eql(['id', 'name', 'lastAccess'], Object.keys(sess));
+                        assert.equal(req, sess.req, 'Test Session#req');
+                        break;
+                    case 7:
+                        req.sessionStore.get(req.sessionHash, function(err, sess){
+                            assert.ok(sess, 'Test MemoryStore#get() when present');
+                            req.session.destroy(function(err){
+                                assert.ok(!err);
+                                req.sessionStore.get(req.sessionHash, function(err, sess){
+                                    assert.ok(!sess, 'Test MemoryStore#get() when not present');
+                                });
+                            });
+                        });
+                        break;
+                    case 8:
+                        var prev = req.session;
+                        req.session.regenerate(function(err){
+                            assert.ok(!err);
+                            assert.notEqual(prev.id, req.session.id, 'Test Session#regenerate()');
+                        });
+                        break;
+                    case 9:
+                        req.session.destroy(function(err){
+                            assert.ok(!err);
+                            assert.ok(!req.session, 'Test Session#destroy()');
+                        });
+                        req.sessionStore.clear(function(err){
+                            assert.ok(!err);
+                            req.sessionStore.length(function(err, len){
+                                assert.equal(0, len, 'Test MemoryStore#clear()');
+                            });
+                        });
+                        break;
+                }
+                next();
+            }
+        );
+
+        server.pending = 10;
+        server.request('GET', '/').end();
+        server.request('GET', '/', { 'Cookie': 'connect.sid=123123' }).end();
+
+        var req = server.request('GET', '/', { 'User-Agent': 'foo' });
+        req.addListener('response', function(res){
+            var setCookie = res.headers['set-cookie'];
+            sid = setCookie.match(/connect\.sid=([^;]+)/)[1];
+            assert.ok(setCookie.indexOf('connect.sid=') === 0, 'Test MemoryStore Set-Cookie connect.sid');
+            assert.ok(setCookie.indexOf('httpOnly') !== -1, 'Test MemoryStore Set-Cookie httpOnly');
+            assert.ok(setCookie.indexOf('expires=') !== -1, 'Test MemoryStore Set-Cookie expires');
+            setTimeout(function(){
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'foo' }).end();
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'bar' }).end();
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'foo' }).end();
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'foo' }).end();
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'foo' }).end();
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'foo' }).end();
+                server.request('GET', '/', { 'Cookie': 'connect.sid=' + sid, 'User-Agent': 'foo' }).end();
+            }, 30);
+        });
+        req.end();
+    }
+};

data/server/node_modules/connect-form/support/connect/test/static.test.js

@@ -0,0 +1,66 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+/**
+ * Path to ./test/fixtures/
+ */
+
+var fixturesPath = __dirname + '/fixtures';
+
+module.exports = {
+    'test valid file': function(){
+        var server = helpers.run(
+            connect.staticProvider(fixturesPath)
+        );
+        var req = server.request('GET', '/user.json');
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                var headers = res.headers,
+                    body = '{\n    "name": "tj",\n    "email": "tj@sencha.com"\n}';
+                assert.equal(200, res.statusCode, 'Test static with valid file status code');
+                assert.equal(body, res.body, 'Test static with valid file response body');
+                assert.equal('application/json', headers['content-type'], 'Test static with valid file Content-Type');
+                assert.equal(body.length, headers['content-length'], 'Test static with valid file Content-Length');
+                assert.ok(headers['last-modified'], 'Test static with valid file Last-Modified');
+                assert.ok(headers['cache-control'], 'Test static with valid file Cache-Control');
+            });
+        });
+        req.end();
+    },
+    
+    'test urlencoded': function(){
+        var server = helpers.run(
+            connect.staticProvider(fixturesPath)
+        );
+        server.assertResponse('GET', '/some%20text.txt', 200, 'whoop', 'Test urlencoded path');
+    },
+
+    'test index.html support': function(){
+        var server = helpers.run(
+            connect.staticProvider(fixturesPath)
+        );
+        server.assertResponse('GET', '/', 200, '<p>Wahoo!</p>', 'Test static index.html support.');
+    },
+
+    'test index.html support when missing': function(){
+        var server = helpers.run(
+            connect.staticProvider(__dirname)
+        );
+        server.assertResponse('GET', '/', 404, 'Cannot GET /', 'Test static index.html support when missing.');
+    },
+
+    'test invalid file': function(){
+        var server = helpers.run(
+            connect.staticProvider(fixturesPath)
+        );
+        server.assertResponse('GET', '/foo.json', 404, 'Cannot GET /foo.json', 'Test invalid static file.');
+    }
+}

data/server/node_modules/connect-form/support/connect/test/utils.test.js

@@ -0,0 +1,65 @@
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('connect/utils'),
+    assert = require('assert');
+
+module.exports = {
+    'test md5()': function(){
+        assert.equal('5JMpgGF2EjbJawLqaqiirQ==', utils.md5('wahoo', 'base64'));
+        assert.equal('e493298061761236c96b02ea6aa8a2ad', utils.md5('wahoo'));
+    },
+
+    'test merge()': function(){
+        assert.eql({ foo: 'bar' }, utils.merge({ foo: 'bar' }));
+        assert.eql({ foo: 'bar', bar: 'baz' }, utils.merge({ foo: 'bar' }, { bar: 'baz' }));
+        assert.eql({ foo: 'baz' }, utils.merge({ foo: 'bar' }, { foo: 'baz' }));
+    },
+
+    'test toBoolean()': function(){
+        assert.strictEqual(true, utils.toBoolean(true));
+        assert.strictEqual(true, utils.toBoolean(1));
+        assert.strictEqual(true, utils.toBoolean('1'));
+        assert.strictEqual(true, utils.toBoolean('true'));
+        assert.strictEqual(true, utils.toBoolean('yes'));
+        assert.strictEqual(true, utils.toBoolean('y'));
+
+        assert.strictEqual(false, utils.toBoolean(false));
+        assert.strictEqual(false, utils.toBoolean(0));
+        assert.strictEqual(false, utils.toBoolean('0'));
+        assert.strictEqual(false, utils.toBoolean('-1'));
+        assert.strictEqual(false, utils.toBoolean('false'));
+        assert.strictEqual(false, utils.toBoolean('no'));
+        assert.strictEqual(false, utils.toBoolean('n'));
+        assert.strictEqual(false, utils.toBoolean('awrasdfasdfas'));
+        assert.strictEqual(false, utils.toBoolean(''));
+    },
+
+    'test parseCookie()': function(){
+        assert.eql({ foo: 'bar' }, utils.parseCookie('foo=bar'));
+        assert.eql({ sid: '123' }, utils.parseCookie('SID=123'));
+        assert.eql({ sid: '123' }, utils.parseCookie('SID=123;SID=somethingElse'));
+        assert.eql({ foo: 'bar', baz: 'raz' }, utils.parseCookie('foo   =  bar; baz = raz'));
+        assert.eql({ fbs: 'uid=0987654321&name=Test User' }, utils.parseCookie('fbs="uid=0987654321&name=Test+User"'));
+    },
+
+    'test serializeCookie()': function(){
+        assert.equal('foo=bar; path=/', utils.serializeCookie('foo', 'bar', { path: '/' }));
+        assert.equal('foo=bar; secure', utils.serializeCookie('foo', 'bar', { secure: true }));
+        assert.equal('foo=bar', utils.serializeCookie('foo', 'bar', { secure: false }));
+        assert.equal('foo=foo%20bar', utils.serializeCookie('foo', 'foo bar'));
+    },
+
+    'test mime.type()': function(){
+        assert.equal('image/png', utils.mime.type('some.png'));
+        assert.equal('image/png', utils.mime.type('some.lame.PNG'));
+        assert.equal('image/png', utils.mime.type('some.lame.png'));
+        assert.equal('image/png', utils.mime.type('path/to/some/ super lame.png'));
+        assert.equal('application/octet-stream', utils.mime.type('foo.bar'));
+        assert.equal('application/octet-stream', utils.mime.type(''));
+        assert.equal('application/octet-stream', utils.mime.type());
+
+    }
+};