vulcan 0.0.1 → 0.0.2

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

@@ -0,0 +1,55 @@
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+function server(headers) {
+    headers = headers || {};
+    headers['Content-Type'] = 'text/plain';
+    return helpers.run(
+        connect.gzip(),
+        connect.createServer(
+            function(req, res){
+                res.writeHead(200, headers);
+                res.end('can be compressed');
+            })
+    );
+}
+
+module.exports = {
+    'test no compression': function(){
+        var req = server().request('GET', '/', { });
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal('can be compressed', res.body);
+            });
+        });
+        req.end();
+    },
+    'test compression': function(){
+        var req = server().request('GET', '/', { 'Accept-Encoding': 'deflate, gzip' });
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal('gzip', res.headers['content-encoding']);
+                // we could uncompress in this test. for now, check
+                // only that it's not the original body:
+                assert.notEqual('can be compressed', res.body);
+            });
+        });
+        req.end();
+    },
+    'test no compression with other content-encoding': function(){
+        var req = server({ 'Content-Encoding': 'bogon' }).
+            request('GET', '/', { 'Accept-Encoding': 'bogon, gzip' });
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal('bogon', res.headers['content-encoding']);
+                assert.equal('can be compressed', res.body);
+            });
+        });
+        req.end();
+    }
+}

data/server/node_modules/connect-form/support/connect/test/helpers/http.js

@@ -0,0 +1,87 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    assert = require('assert'),
+    http = require('http'),
+    net = require('net'),
+    sys = require('sys');
+
+/**
+ * Test base port.
+ */
+
+var port = exports.port = process.env.CONNECT_TEST_PORT || 12345;
+
+connect.Server.prototype.listen = function(){
+    var self = this,
+        client = http.createClient(port),
+        pending = 0;
+
+    /**
+     * Request helper.
+     */
+
+    this.request = function(){
+        if (self.pending === undefined) ++pending;
+        var req = client.request.apply(client, arguments);
+        req.addListener('response', function(res){
+            if (req.buffer) {
+                res.body = '';
+                res.setEncoding('utf8');
+                res.addListener('data', function(chunk){ res.body += chunk });
+            }
+            if (self.pending === undefined) {
+                if (!--pending) {
+                    self.close();
+                }
+            } else if (!--self.pending) {
+                self.close();
+            }
+        });
+        return req;
+    };
+
+    /**
+     * Response assertion helper.
+     */
+
+    this.assertResponse = function(method, path, expectedStatus, expectedBody, msg, fn){
+        msg = msg || 'expected';
+        var req = this.request(method, path);
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal(expectedBody,
+                    res.body,
+                    msg + ' response body of ' + sys.inspect(expectedBody) + ', got ' + sys.inspect(res.body));
+                assert.equal(expectedStatus,
+                    res.statusCode,
+                    msg + ' status code of ' + expectedStatus + ', got ' + res.statusCode);
+                if (fn) fn(res);
+            });
+        });
+        req.end();
+    };
+
+    /**
+     * Assert response headers.
+     */
+
+    this.assertResponseHeaders = function(method, path, headers){
+        var req = this.request(method, path);
+        req.addListener('response', function(res){
+            for (var key in headers) {
+                assert.equal(headers[key], res.headers[key],
+                    'expected response header ' + key + ' of "' + headers[key] + '"'
+                    + ', got "' + res.headers[key] + '"');
+            }
+        });
+        req.end();
+    };
+
+    net.Server.prototype.listen.call(this, this.port = port++);
+    return this;
+}

data/server/node_modules/connect-form/support/connect/test/helpers/index.js

@@ -0,0 +1,12 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect');
+
+exports.port = require('./http').port;
+
+exports.run = function run(){
+    return connect.createServer.apply(this, arguments).listen();
+}

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

@@ -0,0 +1,225 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http'),
+    jsonrpc = require('connect/middleware/jsonrpc')
+
+function run(procedures){
+    var server = helpers.run(
+        connect.jsonrpc(procedures)
+    );
+    server.call = function(obj, fn){
+        var req = server.request('POST', '/', { 'Content-Type': 'application/json; charset=foobar' });
+        req.buffer = true;
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                fn(res, JSON.parse(res.body));
+            });
+        });
+        if (typeof obj === 'object') {
+            obj = JSON.stringify(obj);
+        }
+        req.write(obj);
+        req.end();
+    };
+    return server;
+}
+
+module.exports = {
+    'test invalid version': function(){
+        var server = run({});
+        server.call({
+            jsonrpc: '1.0',
+            method: 'add',
+            params: [1,2],
+            id: 1
+        }, function(res, body){
+            assert.eql({ id: 1, error: { code: jsonrpc.INVALID_REQUEST, message: 'Invalid Request.' }, jsonrpc: '2.0'}, body);
+        });
+    },
+
+    'test invalid id': function(){
+        var server = run({});
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            params: [1,2]
+        }, function(res, body){
+            assert.eql({ id: null, error: { code: jsonrpc.INVALID_REQUEST, message: 'Invalid Request.' }, jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test parse error': function(){
+        var server = run({});
+        server.call('{ "invalid:', function(res, body){
+            assert.eql({ id: null, error: { code: jsonrpc.PARSE_ERROR, message: 'Parse Error.' }, jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test invalid method': function(){
+        var server = run({});
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            id: 1
+        }, function(res, body){
+            assert.eql({ id: 1, error: { code: jsonrpc.METHOD_NOT_FOUND, message: 'Method Not Found.' }, jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test passing method exceptions': function(){
+        var server = run({
+            add: function(a, b){
+                if (arguments.length === 2) {
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        this(null, a + b);
+                    } else {
+                        var err = new Error('Arguments must be numeric.');
+                        err.code = jsonrpc.INVALID_PARAMS;
+                        this(err);
+                    }
+                } else {
+                    this(jsonrpc.INVALID_PARAMS);
+                }
+            }
+        });
+
+        // Invalid params
+
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            params: [1],
+            id: 1
+        }, function(res, body){
+            assert.eql({ id: 1, error: { code: jsonrpc.INVALID_PARAMS, message: 'Invalid Params.' }, jsonrpc: '2.0' }, body);
+        });
+
+        // Valid
+
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            params: [1, 2],
+            id: 2
+        }, function(res, body){
+            assert.eql({ id: 2, result: 3, jsonrpc: '2.0' }, body);
+        });
+
+        // Custom exception
+
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            params: [1, {}],
+            id: 3
+        }, function(res, body){
+            assert.eql({ id: 3, error: { code: jsonrpc.INVALID_PARAMS, message: 'Arguments must be numeric.' }, jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test methode call': function(){
+        var server = run({
+            add: function(a, b){
+                this(null, a + b);
+            }
+        });
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            params: [1,2],
+            id: 1
+        }, function(res, body){
+            assert.eql({ id: 1, result: 3, jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test variable arguments': function(){
+        var server = run({
+            add: function(){
+                var sum = 0;
+                for (var i = 0, len = arguments.length; i < len; ++i) {
+                    sum += arguments[i];
+                }
+                this(null, sum);
+            }
+        });
+        server.call({
+            jsonrpc: '2.0',
+            method: 'add',
+            params: [1,2,3,4,5],
+            id: 1
+        }, function(res, body){
+            assert.eql({ id: 1, result: 15, jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test named params': function(){
+        var server = run({
+            delay: function(ms,   msg, unused){
+                var respond = this;
+                setTimeout(function(){
+                    respond(null, msg);
+                }, ms);
+            },
+            invalid: function(  ){
+                this(null, 'shouldnt reach here because I dont have named param support :)');
+            }
+        });
+
+        server.call({
+            jsonrpc: '2.0',
+            method: 'delay',
+            params: { msg: 'Whoop!', ms: 50 },
+            id: 1
+        }, function(res, body){
+            assert.eql({ id: 1, result: 'Whoop!', jsonrpc: '2.0' }, body);
+        });
+
+        server.call({
+            jsonrpc: '2.0',
+            method: 'invalid',
+            params: { msg: 'Whoop!', ms: 50 },
+            id: 2
+        }, function(res, body){
+            assert.eql({ id: 2, error:
+                { code: jsonrpc.INVALID_PARAMS, message: 'This service does not support named parameters.' },
+                jsonrpc: '2.0' }, body);
+        });
+    },
+
+    'test batch calls': function(){
+        var server = run({
+            multiply: function(a, b){
+                this(null, a * b);
+            },
+            sub: function(a, b){
+                this(null, a - b);
+            }
+        });
+        server.call([{
+            jsonrpc: '2.0',
+            method: 'multiply',
+            params: [2,2],
+            id: 1
+        }, {
+            jsonrpc: '2.0',
+            method: 'sub',
+            params: [2, 1],
+            id: 2
+        },
+        {},
+        { jsonrpc: '2.0', id: 3 }
+        ], function(res, body){
+            assert.eql({ id: 1, result: 4, jsonrpc: '2.0' }, body[0]);
+            assert.eql({ id: 2, result: 1, jsonrpc: '2.0' }, body[1]);
+            assert.eql({ id: null, error: { code: jsonrpc.INVALID_REQUEST, message: 'Invalid Request.' }, jsonrpc: '2.0' }, body[2]);
+            assert.eql({ id: 3, error: { code: jsonrpc.INVALID_REQUEST, message: 'Invalid Request.' }, jsonrpc: '2.0' }, body[3]);
+        });
+    }
+}

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

@@ -0,0 +1,52 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+module.exports = {
+    test: function(){
+        var logs = [];
+        var fakeStream = { write: function(str){ logs.push(str); }};
+        var orig = Date.prototype.toUTCString;
+        Date.prototype.toUTCString = function(){
+            return 'Thu, 27 May 2010 03:23:50 GMT';
+        }
+        var server = helpers.run(
+            connect.logger({ stream: fakeStream }),
+            require('./filters/uppercase')(),
+            require('./providers/echo')()
+        );
+
+        var req = server.request('POST', '/', { 'User-Agent': 'ext-test', 'Referrer': 'http://google.com' });
+        req.buffer = true
+        req.addListener('response', function(res){
+            res.addListener('end', function(){
+                assert.equal('FOOBAR', res.body);
+                assert.equal(
+                    '127.0.0.1 - - [Thu, 27 May 2010 03:23:50 GMT] "POST / HTTP/1.1" 200 - "http://google.com" "ext-test"\n',
+                    logs[0]);
+                Date.prototype.toUTCString = orig;
+            })
+        })
+        req.write('foobar');
+        req.end();
+    },
+    
+    'test custom format': function(){
+        var logs = [];
+        var fakeStream = { write: function(str){ logs.push(str); }};
+        var server = helpers.run(
+            connect.logger({ stream: fakeStream, format: ':method :url' }),
+            require('./filters/uppercase')(),
+            require('./providers/echo')()
+        );
+        server.assertResponse('GET', '/', 200, '', '', function(){
+            assert.equal('GET /\n', logs[0], 'Test logger format option');
+        });
+    }
+}

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

@@ -0,0 +1,69 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    helpers = require('./helpers'),
+    assert = require('assert'),
+    http = require('http');
+
+module.exports = {
+    'test valid http method': function(){
+        var server = helpers.run(
+            connect.bodyDecoder(),
+            connect.methodOverride(),
+            function(req, res){
+                assert.equal('PUT', req.method, 'Test method-override');
+                res.writeHead(200);
+                res.end();
+            }
+        );
+        var req = server.request('POST', '/', { 'Content-Type': 'application/x-www-form-urlencoded' });
+        req.write('_method=put');
+        req.end();
+    },
+
+    'test invalid http method': function(){
+        var server = helpers.run(
+            connect.bodyDecoder(),
+            connect.methodOverride(),
+            function(req, res){
+                assert.equal('POST', req.method, 'Test method-override invalid method');
+                res.writeHead(200);
+                res.end();
+            }
+        );
+        var req = server.request('POST', '/', { 'Content-Type': 'application/x-www-form-urlencoded' });
+        req.write('_method=foobar');
+        req.end();
+    },
+
+    'test custom key': function(){
+        var server = helpers.run(
+            connect.bodyDecoder(),
+            connect.methodOverride('__method__'),
+            function(req, res){
+                assert.equal('PUT', req.method, 'Test method-override custom key');
+                res.writeHead(200);
+                res.end();
+            }
+        );
+        var req = server.request('POST', '/', { 'Content-Type': 'application/x-www-form-urlencoded' });
+        req.write('__method__=put');
+        req.end();
+    },
+    
+    'test X-HTTP-Method-Override header': function(){
+        var server = helpers.run(
+            connect.methodOverride(),
+            function(req, res){
+                assert.equal('PUT', req.method, 'Test X-HTTP-Method-Override');
+                res.writeHead(200);
+                res.end();
+            }
+        );
+        var req = server.request('POST', '/', { 'X-HTTP-Method-Override': 'PUT' });
+        req.end();
+    }
+}