bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/express/test/req.path.js

@@ -0,0 +1,20 @@
+'use strict'
+
+var express = require('../')
+  , request = require('supertest');
+
+describe('req', function(){
+  describe('.path', function(){
+    it('should return the parsed pathname', function(done){
+      var app = express();
+
+      app.use(function(req, res){
+        res.end(req.path);
+      });
+
+      request(app)
+      .get('/login?redirect=/post/1/comments')
+      .expect('/login', done);
+    })
+  })
+})

package/tests/fixtures/corpus/oss-repos/express/test/req.protocol.js

@@ -0,0 +1,113 @@
+'use strict'
+
+var express = require('../')
+  , request = require('supertest');
+
+describe('req', function(){
+  describe('.protocol', function(){
+    it('should return the protocol string', function(done){
+      var app = express();
+
+      app.use(function(req, res){
+        res.end(req.protocol);
+      });
+
+      request(app)
+      .get('/')
+      .expect('http', done);
+    })
+
+    describe('when "trust proxy" is enabled', function(){
+      it('should respect X-Forwarded-Proto', function(done){
+        var app = express();
+
+        app.enable('trust proxy');
+
+        app.use(function(req, res){
+          res.end(req.protocol);
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'https')
+        .expect('https', done);
+      })
+
+      it('should default to the socket addr if X-Forwarded-Proto not present', function(done){
+        var app = express();
+
+        app.enable('trust proxy');
+
+        app.use(function(req, res){
+          req.socket.encrypted = true;
+          res.end(req.protocol);
+        });
+
+        request(app)
+        .get('/')
+        .expect('https', done);
+      })
+
+      it('should ignore X-Forwarded-Proto if socket addr not trusted', function(done){
+        var app = express();
+
+        app.set('trust proxy', '10.0.0.1');
+
+        app.use(function(req, res){
+          res.end(req.protocol);
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'https')
+        .expect('http', done);
+      })
+
+      it('should default to http', function(done){
+        var app = express();
+
+        app.enable('trust proxy');
+
+        app.use(function(req, res){
+          res.end(req.protocol);
+        });
+
+        request(app)
+        .get('/')
+        .expect('http', done);
+      })
+
+      describe('when trusting hop count', function () {
+        it('should respect X-Forwarded-Proto', function (done) {
+          var app = express();
+
+          app.set('trust proxy', 1);
+
+          app.use(function (req, res) {
+            res.end(req.protocol);
+          });
+
+          request(app)
+          .get('/')
+          .set('X-Forwarded-Proto', 'https')
+          .expect('https', done);
+        })
+      })
+    })
+
+    describe('when "trust proxy" is disabled', function(){
+      it('should ignore X-Forwarded-Proto', function(done){
+        var app = express();
+
+        app.use(function(req, res){
+          res.end(req.protocol);
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'https')
+        .expect('http', done);
+      })
+    })
+  })
+})

package/tests/fixtures/corpus/oss-repos/express/test/req.query.js

@@ -0,0 +1,106 @@
+'use strict'
+
+var assert = require('node:assert')
+var express = require('../')
+  , request = require('supertest');
+
+describe('req', function(){
+  describe('.query', function(){
+    it('should default to {}', function(done){
+      var app = createApp();
+
+      request(app)
+      .get('/')
+      .expect(200, '{}', done);
+    });
+
+    it('should default to parse simple keys', function (done) {
+      var app = createApp();
+
+      request(app)
+      .get('/?user[name]=tj')
+      .expect(200, '{"user[name]":"tj"}', done);
+    });
+
+    describe('when "query parser" is extended', function () {
+      it('should parse complex keys', function (done) {
+        var app = createApp('extended');
+
+        request(app)
+        .get('/?foo[0][bar]=baz&foo[0][fizz]=buzz&foo[]=done!')
+        .expect(200, '{"foo":[{"bar":"baz","fizz":"buzz"},"done!"]}', done);
+      });
+
+      it('should parse parameters with dots', function (done) {
+        var app = createApp('extended');
+
+        request(app)
+        .get('/?user.name=tj')
+        .expect(200, '{"user.name":"tj"}', done);
+      });
+    });
+
+    describe('when "query parser" is simple', function () {
+      it('should not parse complex keys', function (done) {
+        var app = createApp('simple');
+
+        request(app)
+        .get('/?user%5Bname%5D=tj')
+        .expect(200, '{"user[name]":"tj"}', done);
+      });
+    });
+
+    describe('when "query parser" is a function', function () {
+      it('should parse using function', function (done) {
+        var app = createApp(function (str) {
+          return {'length': (str || '').length};
+        });
+
+        request(app)
+        .get('/?user%5Bname%5D=tj')
+        .expect(200, '{"length":17}', done);
+      });
+    });
+
+    describe('when "query parser" disabled', function () {
+      it('should not parse query', function (done) {
+        var app = createApp(false);
+
+        request(app)
+        .get('/?user%5Bname%5D=tj')
+        .expect(200, '{}', done);
+      });
+    });
+
+    describe('when "query parser" enabled', function () {
+      it('should not parse complex keys', function (done) {
+        var app = createApp(true);
+
+        request(app)
+        .get('/?user%5Bname%5D=tj')
+        .expect(200, '{"user[name]":"tj"}', done);
+      });
+    });
+
+    describe('when "query parser" an unknown value', function () {
+      it('should throw', function () {
+        assert.throws(createApp.bind(null, 'bogus'),
+          /unknown value.*query parser/)
+      });
+    });
+  })
+})
+
+function createApp(setting) {
+  var app = express();
+
+  if (setting !== undefined) {
+    app.set('query parser', setting);
+  }
+
+  app.use(function (req, res) {
+    res.send(req.query);
+  });
+
+  return app;
+}

package/tests/fixtures/corpus/oss-repos/express/test/req.range.js

@@ -0,0 +1,104 @@
+'use strict'
+
+var express = require('..');
+var request = require('supertest')
+
+describe('req', function(){
+  describe('.range(size)', function(){
+    it('should return parsed ranges', function (done) {
+      var app = express()
+
+      app.use(function (req, res) {
+        res.json(req.range(120))
+      })
+
+      request(app)
+      .get('/')
+      .set('Range', 'bytes=0-50,51-100')
+      .expect(200, '[{"start":0,"end":50},{"start":51,"end":100}]', done)
+    })
+
+    it('should cap to the given size', function (done) {
+      var app = express()
+
+      app.use(function (req, res) {
+        res.json(req.range(75))
+      })
+
+      request(app)
+      .get('/')
+      .set('Range', 'bytes=0-100')
+      .expect(200, '[{"start":0,"end":74}]', done)
+    })
+
+    it('should cap to the given size when open-ended', function (done) {
+      var app = express()
+
+      app.use(function (req, res) {
+        res.json(req.range(75))
+      })
+
+      request(app)
+      .get('/')
+      .set('Range', 'bytes=0-')
+      .expect(200, '[{"start":0,"end":74}]', done)
+    })
+
+    it('should have a .type', function (done) {
+      var app = express()
+
+      app.use(function (req, res) {
+        res.json(req.range(120).type)
+      })
+
+      request(app)
+      .get('/')
+      .set('Range', 'bytes=0-100')
+      .expect(200, '"bytes"', done)
+    })
+
+    it('should accept any type', function (done) {
+      var app = express()
+
+      app.use(function (req, res) {
+        res.json(req.range(120).type)
+      })
+
+      request(app)
+      .get('/')
+      .set('Range', 'users=0-2')
+      .expect(200, '"users"', done)
+    })
+
+    it('should return undefined if no range', function (done) {
+      var app = express()
+
+      app.use(function (req, res) {
+        res.send(String(req.range(120)))
+      })
+
+      request(app)
+      .get('/')
+      .expect(200, 'undefined', done)
+    })
+  })
+
+  describe('.range(size, options)', function(){
+    describe('with "combine: true" option', function(){
+      it('should return combined ranges', function (done) {
+        var app = express()
+
+        app.use(function (req, res) {
+          res.json(req.range(120, {
+            combine: true
+          }))
+        })
+
+        request(app)
+        .get('/')
+        .set('Range', 'bytes=0-50,51-100')
+        .expect(200, '[{"start":0,"end":100}]', done)
+      })
+    })
+  })
+})

package/tests/fixtures/corpus/oss-repos/express/test/req.route.js

@@ -0,0 +1,28 @@
+'use strict'
+
+var express = require('../')
+  , request = require('supertest');
+
+describe('req', function(){
+  describe('.route', function(){
+    it('should be the executed Route', function(done){
+      var app = express();
+
+      app.get('/user/:id{/:op}', function(req, res, next){
+        res.header('path-1', req.route.path)
+        next();
+      });
+
+      app.get('/user/:id/edit', function(req, res){
+        res.header('path-2', req.route.path)
+        res.end();
+      });
+
+      request(app)
+        .get('/user/12/edit')
+        .expect('path-1', '/user/:id{/:op}')
+        .expect('path-2', '/user/:id/edit')
+        .expect(200, done)
+    })
+  })
+})

package/tests/fixtures/corpus/oss-repos/express/test/req.secure.js

@@ -0,0 +1,101 @@
+'use strict'
+
+var express = require('../')
+  , request = require('supertest');
+
+describe('req', function(){
+  describe('.secure', function(){
+    describe('when X-Forwarded-Proto is missing', function(){
+      it('should return false when http', function(done){
+        var app = express();
+
+        app.get('/', function(req, res){
+          res.send(req.secure ? 'yes' : 'no');
+        });
+
+        request(app)
+        .get('/')
+        .expect('no', done)
+      })
+    })
+  })
+
+  describe('.secure', function(){
+    describe('when X-Forwarded-Proto is present', function(){
+      it('should return false when http', function(done){
+        var app = express();
+
+        app.get('/', function(req, res){
+          res.send(req.secure ? 'yes' : 'no');
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'https')
+        .expect('no', done)
+      })
+
+      it('should return true when "trust proxy" is enabled', function(done){
+        var app = express();
+
+        app.enable('trust proxy');
+
+        app.get('/', function(req, res){
+          res.send(req.secure ? 'yes' : 'no');
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'https')
+        .expect('yes', done)
+      })
+
+      it('should return false when initial proxy is http', function(done){
+        var app = express();
+
+        app.enable('trust proxy');
+
+        app.get('/', function(req, res){
+          res.send(req.secure ? 'yes' : 'no');
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'http, https')
+        .expect('no', done)
+      })
+
+      it('should return true when initial proxy is https', function(done){
+        var app = express();
+
+        app.enable('trust proxy');
+
+        app.get('/', function(req, res){
+          res.send(req.secure ? 'yes' : 'no');
+        });
+
+        request(app)
+        .get('/')
+        .set('X-Forwarded-Proto', 'https, http')
+        .expect('yes', done)
+      })
+
+      describe('when "trust proxy" trusting hop count', function () {
+        it('should respect X-Forwarded-Proto', function (done) {
+          var app = express();
+
+          app.set('trust proxy', 1);
+
+          app.get('/', function (req, res) {
+            res.send(req.secure ? 'yes' : 'no');
+          });
+
+          request(app)
+          .get('/')
+          .set('X-Forwarded-Proto', 'https')
+          .expect('yes', done)
+        })
+      })
+    })
+  })
+})

package/tests/fixtures/corpus/oss-repos/express/test/req.signedCookies.js

@@ -0,0 +1,37 @@
+'use strict'
+
+var express = require('../')
+  , request = require('supertest')
+  , cookieParser = require('cookie-parser')
+
+describe('req', function(){
+  describe('.signedCookies', function(){
+    it('should return a signed JSON cookie', function(done){
+      var app = express();
+
+      app.use(cookieParser('secret'));
+
+      app.use(function(req, res){
+        if (req.path === '/set') {
+          res.cookie('obj', { foo: 'bar' }, { signed: true });
+          res.end();
+        } else {
+          res.send(req.signedCookies);
+        }
+      });
+
+      request(app)
+      .get('/set')
+      .end(function(err, res){
+        if (err) return done(err);
+        var cookie = res.header['set-cookie'];
+
+        request(app)
+        .get('/')
+        .set('Cookie', cookie)
+        .expect(200, { obj: { foo: 'bar' } }, done)
+      });
+    })
+  })
+})
+

package/tests/fixtures/corpus/oss-repos/express/test/req.stale.js

@@ -0,0 +1,50 @@
+'use strict'
+
+var express = require('../')
+  , request = require('supertest');
+
+describe('req', function(){
+  describe('.stale', function(){
+    it('should return false when the resource is not modified', function(done){
+      var app = express();
+      var etag = '"12345"';
+
+      app.use(function(req, res){
+        res.set('ETag', etag);
+        res.send(req.stale);
+      });
+
+      request(app)
+      .get('/')
+      .set('If-None-Match', etag)
+      .expect(304, done);
+    })
+
+    it('should return true when the resource is modified', function(done){
+      var app = express();
+
+      app.use(function(req, res){
+        res.set('ETag', '"123"');
+        res.send(req.stale);
+      });
+
+      request(app)
+      .get('/')
+      .set('If-None-Match', '"12345"')
+      .expect(200, 'true', done);
+    })
+
+    it('should return true without response headers', function(done){
+      var app = express();
+
+      app.disable('x-powered-by')
+      app.use(function(req, res){
+        res.send(req.stale);
+      });
+
+      request(app)
+      .get('/')
+      .expect(200, 'true', done);
+    })
+  })
+})