'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', '/lang/en', 200, 'en');
server.assertResponse('GET', '/lang/foobar', 404, 'Cannot GET /lang/foobar');
server.assertResponse('GET', '/out', 404, 'Cannot GET /out');
server.assertResponse('GET', '/items/12', 200, 'item 12');
server.assertResponse('GET', '/items', 200, 'items');
server.assertResponse('GET', '/staff/12', 200, 'GET staff 12');
server.assertResponse('POST', '/staff/12', 200, 'POST staff 12');
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('POST', '/products.json', 404, 'only GET is allowed to /products');
server.assertResponse('PUT', '/products/12', 404, 'only GET is allowed to /products');
server.assertResponse('DELETE', '/products', 404, 'only GET is allowed to /products');
server.assertResponse('GET', '/next', 404, 'Cannot GET /next');
server.assertResponse('GET', '/error', 500, 'Error: boom!');
server.assertResponse('GET', '/cars/%5Bhey%5D', 200, 'format: undefined id: [hey]');
server.assertResponse('GET', '/cars/12', 200, 'format: undefined id: 12');
server.assertResponse('GET', '/cars/12.json', 200, 'format: json id: 12');
server.assertResponse('GET', '/account/12/files/jquery.js', 200, 'file: jquery.js');
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-aa', 404, 'Cannot GET /range/11-aa');
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');
}
exports.echoServer = function (options) {
var port = exports.port;
var protocol = options ? 'https' : 'http';
var server;
exports.port += 1;
function handler(request, response, next) {
var echo = _getRequestJSON(request);
var requestedCode = request.headers['x-give-me-status-dude'];
echo.payload = request.rawBody;
var returnEcho = JSON.stringify(echo);
var headers = {
'Content-Type': 'application/json',
'X-Foo-Bar' : '2342asdf'
};
response.writeHead(requestedCode || 200, headers);
if (request.method !== 'HEAD') {
response.write(returnEcho);
}
response.end();
server.close();
}
if (options) {
server = Connect.createServer(
options,
Connect.bodyParser(),
Connect.router(function (app) {
_routeall(app, /foo(.*)/, handler);
})
);
} else {
server = Connect.createServer(
Connect.bodyParser(),
Gzip(),
Connect.router(function (app) {
_routeall(app, /foo(.*)/, handler);
})
);
}
server.listen(port, 'localhost');
return {
url: protocol + '://localhost:' + port,
serv: server
};
};
cli.main(function(args, options) {
if (options.daemonize && (!options.pid || !options.log)) {
cli.fatal("--pid and --log are required if --daemonize")
cli.getUsage()
}
connect.bodyParser.parse["plain/text"] = function(rawBody) { return rawBody }
connect(
connect.bodyParser(),
connect.router(function(resource) {
resource.get("/ping", function(request, response) {
response.writeHead(200, {"Content-Type": "plain/text"})
response.end("PONG")
})
resource.post("/echo", function(request, response) {
util.log(request.headers, request.body)
response.writeHead(200, {"Content-Type": request.headers["content-type"]})
response.end(request.body)
})
}),
connect["static"](path.join(__dirname, "public"))
).listen(options.port, options.host)
if (options.daemonize) {
daemon.daemonize(options.log, options.pid, function(error, started) {
if (error) {
cli.fatal("unable to make him a daemon:" + error)
console.dir(error.stack)
process.exit(1)
}
})
}
})
'test .match()': function(){
var router = connect.router(function(app){
app.get('/user/:id', function(req, res, next){
req.params.id = parseInt(req.params.id, 10);
next();
});
app.get('/user/:id', function(req, res){
res.end(typeof req.params.id);
});
app.put('/user/:id', function(){});
app.get('/user/:id/edit', function(){});
app.post('/user', function(){});
});
var fn = router.match('/user/12')[0];
fn.keys.should.eql(['id']);
fn.params.id.should.equal('12');
router.match('/').should.be.empty;
router.match('/', 'GET').should.be.empty;
router.match('/user/12', 'GET')[0].should.be.a('function');
router.match('/user/12/edit', 'GET').should.have.length(1);
router.match('/user/12', 'GET').should.have.length(2);
router.match('/user/12', 'PUT').should.have.length(1);
router.match('/user', 'POST').should.have.length(1);
router.match('/user').should.have.length(1);
},
'test several splats': function(){
var app = connect.createServer(
connect.router(function(app){
app.get('/file/*.*', function(req, res){
res.end('file ' + req.params[0] + ' ext ' + req.params[1]);
});
app.get('/move/*/to/*', function(req, res){
res.end('moved ' + req.params[0] + ' to ' + req.params[1]);
});
})
);
assert.response(app,
{ url: '/file/jquery.js' },
{ body: 'file jquery ext js' });
assert.response(app,
{ url: '/file/public/javascripts/jquery.js' },
{ body: 'file public/javascripts/jquery ext js' });
assert.response(app,
{ url: '/move/jquery/to/jquery.js' },
{ body: 'moved jquery to jquery.js' });
},
var pages = module.exports = function pages(o) {
console.log('init pages layer > ', o);
return connect.router(function(app) {
// ### `GET /:filename`
// returns page file in the `templates/pages` directory.
app.get('/:file', function(req, res, next) {
var url = req.url,
file = 'page.' + req.params.file + '.html',
tmpl = 'tmpl.' + file,
hasTmpl = util.hasTmpl(tmpl);
// if requested page does not exist, pass control
// to the next middleware in the stack
if(!hasTmpl) {return next();}
// render file and end response
renderer.render(file, res, {headers: req.headers, content: util.toHtml(tmpl, {
config: renderer.options
})});
});
});
};
'test params': function(){
var app = connect.createServer(
connect.router(function(app){
app.get('/user/:id', function(req, res){
res.end('user ' + req.params.id);
});
app.get('/user/:id/:op', function(req, res){
res.end(req.params.op + 'ing user ' + req.params.id);
});
})
);
assert.response(app,
{ url: '/user/12/' },
{ body: 'user 12' });
assert.response(app,
{ url: '/user/12' },
{ body: 'user 12' });
assert.response(app,
{ url: '/user/tj.holowaychuk' },
{ body: 'user tj.holowaychuk' });
assert.response(app,
{ url: '/user/12/edit' },
{ body: 'editing user 12' });
},
that.setupRoutes= function(server) {
server.use('/', connect.router(function routes(app){
app.post('/auth/form_callback', function(request, response){
request.authenticate( [that.name], function(error, authenticated) {
var redirectUrl= "/"
var parsedUrl= url.parse(request.url, true);
if( parsedUrl.query && parsedUrl.query.redirect_url ) {
redirectUrl= parsedUrl.query.redirect_url;
}
response.writeHead(303, { 'Location': redirectUrl });
response.end('');
})
});
app.get('/auth/form_callback', function(request, response){
response.writeHead(200, {'Content-Type': 'text/html'})
var parsedUrl= url.parse(request.url, true);
var redirectUrl= "";
if( parsedUrl.query && parsedUrl.query.redirect_url ) {
redirectUrl= "?redirect_url="+ parsedUrl.query.redirect_url;
}
response.end("<html><body><form action='/auth/form_callback"+ redirectUrl+ "' method='post'> \n\
<label for='user'>Name</label><input type='text' name='user' id='user'/><br/> \n\
<label for='password'>Password</label><input type='password' name='password' id='password'/> \n\
<input type='submit'/> \n\
</form></body</html>");
});
}));
};
'test OPTIONS': function(){
var app = connect.createServer(
connect.router(function(app){
app.get('/items', function(){});
app.post('/items', function(){});
app.get('/users', function(){});
app.options('/accounts', function(req, res){
res.writeHead(204, { Allow: 'GET' });
res.end();
});
})
);
assert.response(app,
{ url: '/items', method: 'OPTIONS' },
{ body: 'GET,POST', headers: { Allow: 'GET,POST' }});
assert.response(app,
{ url: '/users', method: 'OPTIONS' },
{ body: 'GET', headers: { Allow: 'GET' }});
assert.response(app,
{ url: '/accounts', method: 'OPTIONS' },
{ headers: { Allow: 'GET' }});
},
'test next()': function(){
var hits = [];
var app = connect.createServer(
connect.router(function(app){
app.get('/:user', function(req, res, next){
hits.push('a');
next();
});
app.get('/:user', function(req, res, next){
hits.push('b');
next();
});
app.get('/:user', function(req, res, next){
hits.push('c');
res.end(req.params.user);
});
})
);
assert.response(app,
{ url: '/tj' },
{ body: 'tj' },
function(){
hits.should.eql(['a', 'b', 'c']);
});
},
var WebServer = function(site) {
this.site = site;
this.server = connect.createServer(
// log HTTP requests
connect.logger(),
// decode application/x-www-form-urlencoded and application/json requests
connect.bodyDecoder(),
// populate req.cookies
connect.cookieDecoder(),
// dole out session cookies
connect.session({ store: new MemoryStore({ reapInterval: 5 * MINUTE }) }),
// conditional HTTP GETs
connect.conditionalGet(),
// handle /
connect.router(this.mainHandler()),
// cache manifest for offline app
//connect.cacheManifest(),
// merge static files into /
connect.staticProvider({root: __dirname + "/../public", maxAge: 1000}),
connect.errorHandler({ showStack: true })
);
};
'test .lookup()': function(){
var router = connect.router(function(app){
app.get('/user/:id', function(req, res, next){
req.params.id = parseInt(req.params.id, 10);
next();
});
app.get('/user/:id', function(req, res){
res.end(typeof req.params.id);
});
app.put('/user/:id', function(){});
app.get('/user/:id/edit', function(){});
app.post('/user', function(){});
});
var fn = router.lookup('/user/:id')[0];
fn.regexp.should.be.an.instanceof(RegExp);
fn.path.should.equal('/user/:id');
fn.method.should.equal('GET');
fn.keys.should.eql(['id']);
router.lookup('/user/:id')[0].should.be.a('function');
router.lookup('/user/:id').should.have.length(3);
router.lookup('/user/:id', 'GET').should.have.length(2);
router.lookup('/user/:id', 'get').should.have.length(2);
router.lookup('/user/:id/edit', 'GET').should.have.length(1);
router.lookup('/user/:id', 'PUT').should.have.length(1);
router.lookup('/user/:id', 'FOO').should.be.empty;
},
dbManager.open(function (error, db) {
if ( error ) {
console.log("Mongo DB connection failed.");
}
// Web
connect.createServer(connect.router(function (app) {
// 1. Emergency
// http://127.0.0.1:8210/check
app.get('/check', function(req, res, next) {
emergency(db, req, res);
});
// 2. Notice
app.get('/notice', function(req, res, next) {
var query = url.parse(req.url, true).query;
res.writeHead(200, {'Content-Type' : 'text/html' });
res.end();
});
// 3. SignIn
app.get('/user/auth/login', function(req, res, next) {
signin(db, req, res);
});
})).listen(8210, function() {
console.log('GameServer running at http://127.0.0.1:8210');
});
db.close();
});
exports.main = function(onReadyDeferred, options)
{
var server = CONNECT();
server.use(CONNECT.router(function(app)
{
app.get(/^\/$/, CONNECT.static(__dirname));
app.get(/^\/loader.js/, CONNECT.static(PATH.dirname(require.resolve("sourcemint-loader-js/loader.js"))));
app.get(/^\/packages\/([^\/]*?)(?:\.js)?(\/.*)?$/, BUNDLER.hoist(__dirname + "/packages/$1", {
distributionBasePath: __dirname + "/dist",
packageIdHashSeed: "__EXAMPLE__"
}));
}));
/*TEST*/ if (onReadyDeferred) {
/*TEST*/ server.once("listening", function() {
/*TEST*/ onReadyDeferred.resolve(function onTestDone(stoppedCallback) {
/*TEST*/ server.once("close", function() {
/*TEST*/ stoppedCallback();
/*TEST*/ });
/*TEST*/ server.close();
/*TEST*/ });
/*TEST*/ });
/*TEST*/ }
server.listen(options.port, "127.0.0.1");
console.log("Server running at http://127.0.0.1:" + options.port + "/");
}
'test methods': function(){
var app = connect.createServer(
connect.router(function(app){
app.get('/', function(req, res){
res.end('GET /');
});
app.post('/', function(req, res){
res.end('POST /');
});
app.put('/', function(req, res){
res.end('PUT /');
});
})
);
assert.response(app,
{ url: '/' },
{ body: 'GET /' });
assert.response(app,
{ url: '/', method: 'POST' },
{ body: 'POST /' });
assert.response(app,
{ url: '/', method: 'PUT' },
{ body: 'PUT /' });
},
function server (store) {
var webserver = connect.createServer();
webserver.use(connect.bodyParser());
webserver.use(sesame({ store : store }));
webserver.use(connect.router(function (app) {
app.get('/whoami', function (req, res) {
res.writeHead(200, { 'Content-Type' : 'text/html' });
res.end(req.session.name || 'nobody');
});
app.post('/sign-in', function (req, res) {
req.on('data', function (body) {
var name = body.toString().match(/name=(.+)/)[1];
req.session = { name : name };
res.writeHead(200, { 'Content-Type' : 'text/html' });
res.end('ok');
});
});
app.get('/sign-out', function (req, res) {
req.session = {};
res.writeHead(200, { 'Content-Type' : 'text/html' });
res.end('ok');
});
}));
return webserver;
}
(function () {
"use strict";
var steve = require('./steve')
, connect = require('connect')
, _ = require('underscore')
, forEachAsync = require('forEachAsync')
, app = connect.createServer()
;
function getHello(request, response) {
response.json(request.params);
response.end();
}
function router(rest) {
rest.get('/hello/:name?', getHello);
}
app
.use(steve)
.use(connect.router(router))
;
module.exports = app;
}());
'test optional params': function(){
var app = connect.createServer(
connect.router(function(app){
app.get('/user/:id?', function(req, res){
res.end('user ' + (req.params.id || 'account'));
});
app.get('/account/:id?/:op', function(req, res){
res.end(req.params.op + 'ing user ' + (req.params.id || 'account'));
});
})
);
assert.response(app,
{ url: '/user/12' },
{ body: 'user 12' });
assert.response(app,
{ url: '/account/edit' },
{ body: 'editing user account' });
assert.response(app,
{ url: '/account/12/edit' },
{ body: 'editing user 12' });
},
'test next(err)': function(){
var hits = [];
var app = connect.createServer(
connect.router(function(app){
app.get('/:user', function(req, res, next){
hits.push('a');
next();
});
app.get('/:user', function(req, res, next){
hits.push('b');
next(new Error('keyboard cat'));
});
app.get('/:user', function(req, res, next){
hits.push('c');
res.end(req.params.user);
});
}),
function(err, req, res, next) {
res.end(err.toString());
}
);
assert.response(app,
{ url: '/tj' },
{ body: 'Error: keyboard cat' },
function(){
hits.should.eql(['a', 'b']);
});
},
ent1.$save( function(err,ent1) {
sys.puts(ent1);
sys.puts('http://localhost:3000/seneca/1.0/entity/test/foo/bar/id/'+ent1.id);
var server = connect.createServer(
connect.router(seneca.router)
);
server.listen(3000);
});
that.setupRoutes= function(server) {
server.use('/', connect.router(function routes(app){
app.get('/auth/bitbucket_callback', function(req, res){
req.authenticate([that.name], {scope: req.session[that.name + '_auth_scope']}, function(error, authenticated) {
res.writeHead(303, { 'Location': req.session.bitbucket_redirect_url });
res.end('');
});
});
}));
}
that.setupRoutes= function(server) {
server.use('/', connect.router(function routes(app){
app.get('/auth/twitter_callback', function(req, res){
req.authenticate([that.name], function(error, authenticated) {
res.writeHead(303, { 'Location': req.session.twitter_redirect_url });
res.end('');
});
});
}));
}
target: function() {
server = connect.createServer(
connect.cookieParser(),
connect.session({
store: ng.db.getMongoStore(),
secret: 'blah',
fingerprint: '',
cookie: {
maxAge: 12 * 24 * 60 * 60 * 1000
}
}),
connect.bodyParser(),
connect.router(routes),
connect.static('./static')
)
var sio = io.listen(server, {'log level': 3})
sio.set('authorization', function(data, accept) {
var cookies = connect.utils.parseCookie(data.headers.cookie)
, sessionId = cookies['connect.sid']
if (!sessionId) {
accept(null, false)
return
}
ng.db.getMongoStore().get(sessionId, function(err, session) {
if (err) {
accept(err, false)
return
}
if (!session) {
accept(null, false)
return
}
data.session = session
accept(null, true)
})
})
sio.sockets.on('connection', function(socket) {
ng.clientSocket.onSocketReady(socket, socket.handshake.session)
})
ng.log.log('Starting HTTP Server: ' + ng.conf.server_ip + ':' + ng.conf.server_port)
server.listen(ng.conf.server_port, ng.conf.server_ip, function() {
console.log(arguments)
})
}
var Server = exports = module.exports = function Server(middleware){
var self = this;
this.config = {};
this.settings = {};
this.redirects = {};
this.isCallbacks = {};
this.viewHelpers = {};
this.dynamicViewHelpers = {};
this.errorHandlers = [];
connect.Server.call(this, []);
// Default "home" to /
this.set('home', '/');
// Set "env" to NODE_ENV, defaulting to "development"
this.set('env', process.env.NODE_ENV || 'development');
// Expose objects to each other
this.use(function(req, res, next){
req.query = {};
res.headers = { 'X-Powered-By': 'Express' };
req.app = res.app = self;
req.res = res;
res.req = req;
req.next = next;
// Assign req.params.get
if (req.url.indexOf('?') > 0) {
var query = url.parse(req.url).query;
req.query = exports.parseQueryString(query);
}
next();
});
// Apply middleware
if (middleware) {
middleware.forEach(function(fn){
self.use(fn);
});
}
// Use router, expose as app.get(), etc
var fn = router(function(app){ self.routes = app; });
this.__defineGetter__('router', function(){
this.__usedRouter = true;
return fn;
});
// Default production configuration
this.configure('production', function(){
this.enable('cache views');
});
};
that.setupRoutes= function(server) {
server.use('/', connect.router(function routes(app){
function handleJanrainCallback(req,res) {
if( req.method == 'GET' ) req.getAuthDetails().janrain_came_back_with_get= true; // If we get a GET to this url it suggests a login failure.
req.authenticate([that.name], function(error, authenticated) {
res.writeHead(303, { 'Location': req.getAuthDetails().janrain_redirect_url });
res.end('');
})
}
app.get('/auth/janrain_callback', handleJanrainCallback);
app.post('/auth/janrain_callback', handleJanrainCallback);
}));
}
setupRoutes: function(server) {
server.use('/', connect.router(function routes(app) {
app.get("/auth/github_callback", function(req, res) {
req.authenticate([name], {
scope: req.session[name + "_auth_scope"]
}, function(error, authenticated) {
res.writeHead(303, {
"Location": req.session.github_redirect_url
});
res.end("");
});
});
}));
},
function create(options) {
function router(app) {
/*
app.get('/fs-meta', getAllFsFilesInfo);
app.get('/fs-meta/*', getFsFileInfo);
app.delete('/fs-meta/*', removeFile);
app.get('/fs/*', getFsFile);
app.post('/fs/*', createFsFile);
app.put('/fs/*', createFsFile);
*/
app.post('/meta/new', createIds);
app.get('/meta/:id', getMetadata);
app.delete('/meta/:id', removeFile);
// deprecated
app.delete('/files/:id', removeFile);
app.post('/files/new', createIds);
app.post('/files', receiveFiles);
app.get('/files/:id/:filename?', sendFile);
}
options = options || {};
// there could potentially be a race condition here at startup
// sholud be negligable
storage = require('./redis-wrapper').create(options.redis || {});
filesDir = options.files;
if (options.allowUserSpecifiedIds) {
allowUserSpecifiedIds = true;
}
server = connect.createServer(
connect.cors()
, connect.static(options.client || __dirname + '/../public')
, connect.bodyParser()
, connect.query()
//, connect.methodOverride()
, connect.router(router)
// Development
, connect.errorHandler({ dumpExceptions: true, showStack: true })
// Production
//, connect.errorHandler()
);
return server;
}
module.exports = function () {
var connect = require('connect'),
fs = require('fs'),
utils = require('./build/utils'),
tests = [],
html = fs.readFileSync(__dirname + "/btest/test.html", "utf-8"),
pack = require('./build/pack'),
conf = require('./build/conf'),
doc,
modules,
specs,
app = connect(
connect.static(__dirname + "/../lib/"),
connect.static(__dirname + "/../"),
connect.router(function (app) {
app.get('/', function (req, res) {
res.writeHead(200, {
"Cache-Control": "no-cache",
"Content-Type": "text/html"
});
res.end(doc);
});
})
);
//HACK: Openlayers causes weird stuff with the browser runner, so lets pop it off the list until we fix it
var openlayers = conf.thirdpartyIncludes.pop();
if (openlayers !== "OpenLayers.js") {
console.log("HACK: we wanted to pop OpenLayers off but it looks like it wasn't the last one anymore");
}
modules = pack();
utils.collect(__dirname + "/../test", tests);
specs = tests.reduce(function (str, file) {
str += '<script src="' +
file.replace(/^.*test/, "test") +
'" type="text/javascript" charset="utf-8"></script>\n';
return str;
}, "");
doc = html.replace(/<!-- SPECS -->/g, specs).replace(/##FILES##/g, modules.js);
app.listen(3000);
process.stdout.write("Test Server running on:");
process.stdout.write("http://127.0.0.1:3000");
};
'test regular expressions': function(){
var app = connect.createServer(
connect.router(function(app){
app.get(/\/commits\/(\w+)\.\.(\w+)\/?/i, function(req, res){
res.end(
'from ' + req.params[0]
+ ' to ' + req.params[1]);
});
})
);
assert.response(app,
{ url: '/commits/abc..def' },
{ body: 'from abc to def' });
},
'test HEAD': function(){
var app = connect.createServer(
connect.router(function(app){
app.get('/items', function(req, res){
res.end('HEAD' == req.method
? ''
: 'foo, bar, baz');
});
})
);
assert.response(app,
{ url: '/items', method: 'HEAD' },
{ body: '' });
},