test/res.download.js

   1 'use strict'
   2
   3 var after = require('after');
   4 var assert = require('assert')
   5 var asyncHooks = tryRequire('async_hooks')
   6 var Buffer = require('safe-buffer').Buffer
   7 var express = require('..');
   8 var path = require('path')
   9 var request = require('supertest');
  10 var utils = require('./support/utils')
  11
  12 var FIXTURES_PATH = path.join(__dirname, 'fixtures')
  13
  14 var describeAsyncHooks = typeof asyncHooks.AsyncLocalStorage === 'function'
  15   ? describe
  16   : describe.skip
  17
  18 describe('res', function(){
  19   describe('.download(path)', function(){
  20     it('should transfer as an attachment', function(done){
  21       var app = express();
  22
  23       app.use(function(req, res){
  24         res.download('test/fixtures/user.html');
  25       });
  26
  27       request(app)
  28       .get('/')
  29       .expect('Content-Type', 'text/html; charset=utf-8')
  30       .expect('Content-Disposition', 'attachment; filename="user.html"')
  31       .expect(200, '<p>{{user.name}}</p>', done)
  32     })
  33
  34     it('should accept range requests', function (done) {
  35       var app = express()
  36
  37       app.get('/', function (req, res) {
  38         res.download('test/fixtures/user.html')
  39       })
  40
  41       request(app)
  42         .get('/')
  43         .expect('Accept-Ranges', 'bytes')
  44         .expect(200, '<p>{{user.name}}</p>', done)
  45     })
  46
  47     it('should respond with requested byte range', function (done) {
  48       var app = express()
  49
  50       app.get('/', function (req, res) {
  51         res.download('test/fixtures/user.html')
  52       })
  53
  54       request(app)
  55         .get('/')
  56         .set('Range', 'bytes=0-2')
  57         .expect('Content-Range', 'bytes 0-2/20')
  58         .expect(206, '<p>', done)
  59     })
  60   })
  61
  62   describe('.download(path, filename)', function(){
  63     it('should provide an alternate filename', function(done){
  64       var app = express();
  65
  66       app.use(function(req, res){
  67         res.download('test/fixtures/user.html', 'document');
  68       });
  69
  70       request(app)
  71       .get('/')
  72       .expect('Content-Type', 'text/html; charset=utf-8')
  73       .expect('Content-Disposition', 'attachment; filename="document"')
  74       .expect(200, done)
  75     })
  76   })
  77
  78   describe('.download(path, fn)', function(){
  79     it('should invoke the callback', function(done){
  80       var app = express();
  81       var cb = after(2, done);
  82
  83       app.use(function(req, res){
  84         res.download('test/fixtures/user.html', cb);
  85       });
  86
  87       request(app)
  88       .get('/')
  89       .expect('Content-Type', 'text/html; charset=utf-8')
  90       .expect('Content-Disposition', 'attachment; filename="user.html"')
  91       .expect(200, cb);
  92     })
  93
  94     describeAsyncHooks('async local storage', function () {
  95       it('should presist store', function (done) {
  96         var app = express()
  97         var cb = after(2, done)
  98         var store = { foo: 'bar' }
  99
 100         app.use(function (req, res, next) {
 101           req.asyncLocalStorage = new asyncHooks.AsyncLocalStorage()
 102           req.asyncLocalStorage.run(store, next)
 103         })
 104
 105         app.use(function (req, res) {
 106           res.download('test/fixtures/name.txt', function (err) {
 107             if (err) return cb(err)
 108
 109             var local = req.asyncLocalStorage.getStore()
 110
 111             assert.strictEqual(local.foo, 'bar')
 112             cb()
 113           })
 114         })
 115
 116         request(app)
 117           .get('/')
 118           .expect('Content-Type', 'text/plain; charset=utf-8')
 119           .expect('Content-Disposition', 'attachment; filename="name.txt"')
 120           .expect(200, 'tobi', cb)
 121       })
 122
 123       it('should presist store on error', function (done) {
 124         var app = express()
 125         var store = { foo: 'bar' }
 126
 127         app.use(function (req, res, next) {
 128           req.asyncLocalStorage = new asyncHooks.AsyncLocalStorage()
 129           req.asyncLocalStorage.run(store, next)
 130         })
 131
 132         app.use(function (req, res) {
 133           res.download('test/fixtures/does-not-exist', function (err) {
 134             var local = req.asyncLocalStorage.getStore()
 135
 136             if (local) {
 137               res.setHeader('x-store-foo', String(local.foo))
 138             }
 139
 140             res.send(err ? 'got ' + err.status + ' error' : 'no error')
 141           })
 142         })
 143
 144         request(app)
 145           .get('/')
 146           .expect(200)
 147           .expect('x-store-foo', 'bar')
 148           .expect('got 404 error')
 149           .end(done)
 150       })
 151     })
 152   })
 153
 154   describe('.download(path, options)', function () {
 155     it('should allow options to res.sendFile()', function (done) {
 156       var app = express()
 157
 158       app.use(function (req, res) {
 159         res.download('test/fixtures/.name', {
 160           dotfiles: 'allow',
 161           maxAge: '4h'
 162         })
 163       })
 164
 165       request(app)
 166         .get('/')
 167         .expect(200)
 168         .expect('Content-Disposition', 'attachment; filename=".name"')
 169         .expect('Cache-Control', 'public, max-age=14400')
 170         .expect(utils.shouldHaveBody(Buffer.from('tobi')))
 171         .end(done)
 172     })
 173
 174     describe('with "headers" option', function () {
 175       it('should set headers on response', function (done) {
 176         var app = express()
 177
 178         app.use(function (req, res) {
 179           res.download('test/fixtures/user.html', {
 180             headers: {
 181               'X-Foo': 'Bar',
 182               'X-Bar': 'Foo'
 183             }
 184           })
 185         })
 186
 187         request(app)
 188           .get('/')
 189           .expect(200)
 190           .expect('X-Foo', 'Bar')
 191           .expect('X-Bar', 'Foo')
 192           .end(done)
 193       })
 194
 195       it('should use last header when duplicated', function (done) {
 196         var app = express()
 197
 198         app.use(function (req, res) {
 199           res.download('test/fixtures/user.html', {
 200             headers: {
 201               'X-Foo': 'Bar',
 202               'x-foo': 'bar'
 203             }
 204           })
 205         })
 206
 207         request(app)
 208           .get('/')
 209           .expect(200)
 210           .expect('X-Foo', 'bar')
 211           .end(done)
 212       })
 213
 214       it('should override Content-Type', function (done) {
 215         var app = express()
 216
 217         app.use(function (req, res) {
 218           res.download('test/fixtures/user.html', {
 219             headers: {
 220               'Content-Type': 'text/x-custom'
 221             }
 222           })
 223         })
 224
 225         request(app)
 226           .get('/')
 227           .expect(200)
 228           .expect('Content-Type', 'text/x-custom')
 229           .end(done)
 230       })
 231
 232       it('should not set headers on 404', function (done) {
 233         var app = express()
 234
 235         app.use(function (req, res) {
 236           res.download('test/fixtures/does-not-exist', {
 237             headers: {
 238               'X-Foo': 'Bar'
 239             }
 240           })
 241         })
 242
 243         request(app)
 244           .get('/')
 245           .expect(404)
 246           .expect(utils.shouldNotHaveHeader('X-Foo'))
 247           .end(done)
 248       })
 249
 250       describe('when headers contains Content-Disposition', function () {
 251         it('should be ignored', function (done) {
 252           var app = express()
 253
 254           app.use(function (req, res) {
 255             res.download('test/fixtures/user.html', {
 256               headers: {
 257                 'Content-Disposition': 'inline'
 258               }
 259             })
 260           })
 261
 262           request(app)
 263             .get('/')
 264             .expect(200)
 265             .expect('Content-Disposition', 'attachment; filename="user.html"')
 266             .end(done)
 267         })
 268
 269         it('should be ignored case-insensitively', function (done) {
 270           var app = express()
 271
 272           app.use(function (req, res) {
 273             res.download('test/fixtures/user.html', {
 274               headers: {
 275                 'content-disposition': 'inline'
 276               }
 277             })
 278           })
 279
 280           request(app)
 281             .get('/')
 282             .expect(200)
 283             .expect('Content-Disposition', 'attachment; filename="user.html"')
 284             .end(done)
 285         })
 286       })
 287     })
 288
 289     describe('with "root" option', function () {
 290       it('should allow relative path', function (done) {
 291         var app = express()
 292
 293         app.use(function (req, res) {
 294           res.download('name.txt', {
 295             root: FIXTURES_PATH
 296           })
 297         })
 298
 299         request(app)
 300           .get('/')
 301           .expect(200)
 302           .expect('Content-Disposition', 'attachment; filename="name.txt"')
 303           .expect(utils.shouldHaveBody(Buffer.from('tobi')))
 304           .end(done)
 305       })
 306
 307       it('should allow up within root', function (done) {
 308         var app = express()
 309
 310         app.use(function (req, res) {
 311           res.download('fake/../name.txt', {
 312             root: FIXTURES_PATH
 313           })
 314         })
 315
 316         request(app)
 317           .get('/')
 318           .expect(200)
 319           .expect('Content-Disposition', 'attachment; filename="name.txt"')
 320           .expect(utils.shouldHaveBody(Buffer.from('tobi')))
 321           .end(done)
 322       })
 323
 324       it('should reject up outside root', function (done) {
 325         var app = express()
 326
 327         app.use(function (req, res) {
 328           var p = '..' + path.sep +
 329             path.relative(path.dirname(FIXTURES_PATH), path.join(FIXTURES_PATH, 'name.txt'))
 330
 331           res.download(p, {
 332             root: FIXTURES_PATH
 333           })
 334         })
 335
 336         request(app)
 337           .get('/')
 338           .expect(403)
 339           .expect(utils.shouldNotHaveHeader('Content-Disposition'))
 340           .end(done)
 341       })
 342
 343       it('should reject reading outside root', function (done) {
 344         var app = express()
 345
 346         app.use(function (req, res) {
 347           res.download('../name.txt', {
 348             root: FIXTURES_PATH
 349           })
 350         })
 351
 352         request(app)
 353           .get('/')
 354           .expect(403)
 355           .expect(utils.shouldNotHaveHeader('Content-Disposition'))
 356           .end(done)
 357       })
 358     })
 359   })
 360
 361   describe('.download(path, filename, fn)', function(){
 362     it('should invoke the callback', function(done){
 363       var app = express();
 364       var cb = after(2, done);
 365
 366       app.use(function(req, res){
 367         res.download('test/fixtures/user.html', 'document', cb)
 368       });
 369
 370       request(app)
 371       .get('/')
 372       .expect('Content-Type', 'text/html; charset=utf-8')
 373       .expect('Content-Disposition', 'attachment; filename="document"')
 374       .expect(200, cb);
 375     })
 376   })
 377
 378   describe('.download(path, filename, options, fn)', function () {
 379     it('should invoke the callback', function (done) {
 380       var app = express()
 381       var cb = after(2, done)
 382       var options = {}
 383
 384       app.use(function (req, res) {
 385         res.download('test/fixtures/user.html', 'document', options, cb)
 386       })
 387
 388       request(app)
 389       .get('/')
 390       .expect(200)
 391       .expect('Content-Type', 'text/html; charset=utf-8')
 392       .expect('Content-Disposition', 'attachment; filename="document"')
 393       .end(cb)
 394     })
 395
 396     it('should allow options to res.sendFile()', function (done) {
 397       var app = express()
 398
 399       app.use(function (req, res) {
 400         res.download('test/fixtures/.name', 'document', {
 401           dotfiles: 'allow',
 402           maxAge: '4h'
 403         })
 404       })
 405
 406       request(app)
 407         .get('/')
 408         .expect(200)
 409         .expect('Content-Disposition', 'attachment; filename="document"')
 410         .expect('Cache-Control', 'public, max-age=14400')
 411         .expect(utils.shouldHaveBody(Buffer.from('tobi')))
 412         .end(done)
 413     })
 414
 415     describe('when options.headers contains Content-Disposition', function () {
 416       it('should be ignored', function (done) {
 417         var app = express()
 418
 419         app.use(function (req, res) {
 420           res.download('test/fixtures/user.html', 'document', {
 421             headers: {
 422               'Content-Type': 'text/x-custom',
 423               'Content-Disposition': 'inline'
 424             }
 425           })
 426         })
 427
 428         request(app)
 429         .get('/')
 430         .expect(200)
 431         .expect('Content-Type', 'text/x-custom')
 432         .expect('Content-Disposition', 'attachment; filename="document"')
 433         .end(done)
 434       })
 435
 436       it('should be ignored case-insensitively', function (done) {
 437         var app = express()
 438
 439         app.use(function (req, res) {
 440           res.download('test/fixtures/user.html', 'document', {
 441             headers: {
 442               'content-type': 'text/x-custom',
 443               'content-disposition': 'inline'
 444             }
 445           })
 446         })
 447
 448         request(app)
 449         .get('/')
 450         .expect(200)
 451         .expect('Content-Type', 'text/x-custom')
 452         .expect('Content-Disposition', 'attachment; filename="document"')
 453         .end(done)
 454       })
 455     })
 456   })
 457
 458   describe('on failure', function(){
 459     it('should invoke the callback', function(done){
 460       var app = express();
 461
 462       app.use(function (req, res, next) {
 463         res.download('test/fixtures/foobar.html', function(err){
 464           if (!err) return next(new Error('expected error'));
 465           res.send('got ' + err.status + ' ' + err.code);
 466         });
 467       });
 468
 469       request(app)
 470       .get('/')
 471       .expect(200, 'got 404 ENOENT', done);
 472     })
 473
 474     it('should remove Content-Disposition', function(done){
 475       var app = express()
 476
 477       app.use(function (req, res, next) {
 478         res.download('test/fixtures/foobar.html', function(err){
 479           if (!err) return next(new Error('expected error'));
 480           res.end('failed');
 481         });
 482       });
 483
 484       request(app)
 485         .get('/')
 486         .expect(utils.shouldNotHaveHeader('Content-Disposition'))
 487         .expect(200, 'failed', done)
 488     })
 489   })
 490 })
 491
 492 function tryRequire (name) {
 493   try {
 494     return require(name)
 495   } catch (e) {
 496     return {}
 497   }
 498 }