mirror of
https://github.com/strapi/strapi.git
synced 2025-07-30 12:29:30 +00:00
1048 lines
25 KiB
JavaScript
Executable File
1048 lines
25 KiB
JavaScript
Executable File
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const stderr = require('test-console').stderr;
|
|
const request = require('supertest');
|
|
const assert = require('assert');
|
|
|
|
const strapi = require('../..');
|
|
|
|
const AssertionError = assert.AssertionError;
|
|
|
|
describe('app', function () {
|
|
it('should handle socket errors', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.socket.emit('error', new Error('boom'));
|
|
});
|
|
|
|
app.on('error', function (err) {
|
|
err.message.should.equal('boom');
|
|
done();
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.end(function () {});
|
|
});
|
|
|
|
it('should not .writeHead when !socket.writable', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.socket.writable = false;
|
|
this.status = 204;
|
|
this.res.writeHead = this.res.end = function () {
|
|
throw new Error('response sent');
|
|
};
|
|
});
|
|
|
|
setImmediate(done);
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.end(function () {});
|
|
});
|
|
|
|
it('should set development env when NODE_ENV missing', function () {
|
|
const NODE_ENV = process.env.NODE_ENV;
|
|
process.env.NODE_ENV = '';
|
|
const app = strapi.server();
|
|
process.env.NODE_ENV = NODE_ENV;
|
|
assert.equal(app.env, 'development');
|
|
});
|
|
});
|
|
|
|
describe('app.toJSON()', function () {
|
|
it('should work', function () {
|
|
const app = strapi.server();
|
|
const obj = app.toJSON();
|
|
|
|
obj.should.eql({
|
|
subdomainOffset: 2,
|
|
env: 'test'
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('app.inspect()', function () {
|
|
it('should work', function () {
|
|
const util = require('util');
|
|
const str = util.inspect(strapi);
|
|
});
|
|
});
|
|
|
|
describe('app.use(fn)', function () {
|
|
it('should compose middleware', function (done) {
|
|
const app = strapi.server();
|
|
const calls = [];
|
|
|
|
app.use(function * (next) {
|
|
calls.push(1);
|
|
yield next;
|
|
calls.push(6);
|
|
});
|
|
|
|
app.use(function * (next) {
|
|
calls.push(2);
|
|
yield next;
|
|
calls.push(5);
|
|
});
|
|
|
|
app.use(function * (next) {
|
|
calls.push(3);
|
|
yield next;
|
|
calls.push(4);
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(404)
|
|
.end(function (err) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
calls.should.eql([1, 2, 3, 4, 5, 6]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should error when a non-generator function is passed', function () {
|
|
const app = strapi.server();
|
|
|
|
try {
|
|
app.use(function () {});
|
|
} catch (err) {
|
|
err.message.should.equal('app.use() requires a generator function');
|
|
}
|
|
});
|
|
|
|
it('should not error when a non-generator function is passed when .experimental=true', function () {
|
|
const app = strapi.server();
|
|
app.experimental = true;
|
|
app.use(function () {});
|
|
});
|
|
});
|
|
|
|
describe('app.onerror(err)', function () {
|
|
it('should throw an error if a non-error is given', function (done) {
|
|
const app = strapi.server();
|
|
|
|
try {
|
|
app.onerror('foo');
|
|
|
|
should.fail();
|
|
} catch (err) {
|
|
err.should.be.instanceOf(AssertionError);
|
|
err.message.should.equal('non-error thrown: foo');
|
|
}
|
|
|
|
done();
|
|
});
|
|
|
|
it('should do nothing if status is 404', function (done) {
|
|
const app = strapi.server();
|
|
const err = new Error();
|
|
|
|
err.status = 404;
|
|
|
|
const output = stderr.inspectSync(function () {
|
|
app.onerror(err);
|
|
});
|
|
|
|
output.should.eql([]);
|
|
|
|
done();
|
|
});
|
|
|
|
it('should do nothing if env is test', function (done) {
|
|
const app = strapi.server();
|
|
const err = new Error();
|
|
|
|
const output = stderr.inspectSync(function () {
|
|
app.onerror(err);
|
|
});
|
|
|
|
output.should.eql([]);
|
|
|
|
done();
|
|
});
|
|
|
|
it('should log the error to stderr', function (done) {
|
|
const app = strapi.server();
|
|
app.env = 'dev';
|
|
|
|
const err = new Error();
|
|
err.stack = 'Foo';
|
|
|
|
const output = stderr.inspectSync(function () {
|
|
app.onerror(err);
|
|
});
|
|
|
|
output.should.eql(['\n', ' Foo\n', '\n']);
|
|
|
|
done();
|
|
});
|
|
|
|
it('should use err.toString() instad of err.stack', function (done) {
|
|
const app = strapi.server();
|
|
app.env = 'dev';
|
|
|
|
const err = new Error('mock stack null');
|
|
err.stack = null;
|
|
|
|
const output = stderr.inspectSync(function () {
|
|
app.onerror(err);
|
|
});
|
|
|
|
output.should.eql(['\n', ' Error: mock stack null\n', '\n']);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
describe('app.respond', function () {
|
|
describe('when this.respond === false', function () {
|
|
it('should bypass app.respond', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = 'Hello';
|
|
this.respond = false;
|
|
|
|
const res = this.res;
|
|
res.statusCode = 200;
|
|
setImmediate(function () {
|
|
res.setHeader('Content-Type', 'text/plain');
|
|
res.end('lol');
|
|
});
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(200)
|
|
.expect('lol')
|
|
.end(done);
|
|
});
|
|
});
|
|
|
|
describe('when HEAD is used', function () {
|
|
it('should not respond with the body', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = 'Hello';
|
|
});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect(200)
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
res.should.have.header('Content-Type', 'text/plain; charset=utf-8');
|
|
res.should.have.header('Content-Length', '5');
|
|
assert(res.text.length == 0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should keep json headers', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = {
|
|
hello: 'world'
|
|
};
|
|
});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect(200)
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
res.should.have.header('Content-Type', 'application/json; charset=utf-8');
|
|
res.should.have.header('Content-Length', '17');
|
|
assert(res.text.length == 0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should keep string headers', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = 'hello world';
|
|
});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect(200)
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
res.should.have.header('Content-Type', 'text/plain; charset=utf-8');
|
|
res.should.have.header('Content-Length', '11');
|
|
assert(res.text.length == 0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should keep buffer headers', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = new Buffer('hello world');
|
|
});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect(200)
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
res.should.have.header('Content-Type', 'application/octet-stream');
|
|
res.should.have.header('Content-Length', '11');
|
|
assert(res.text.length == 0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should respond with a 404 if no body was set', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect(404, done);
|
|
});
|
|
|
|
it('should respond with a 200 if body = ""', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = '';
|
|
});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect(200, done);
|
|
});
|
|
|
|
it('should not overwrite the content-type', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 200;
|
|
this.type = 'application/javascript';
|
|
});
|
|
|
|
request(app.listen())
|
|
.head('/')
|
|
.expect('content-type', /application\/javascript/)
|
|
.expect(200, done);
|
|
});
|
|
});
|
|
|
|
describe('when no middleware are present', function () {
|
|
it('should 404', function (done) {
|
|
const app = strapi.server();
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(404, done);
|
|
});
|
|
});
|
|
|
|
describe('when res has already been written to', function () {
|
|
it('should not cause an app error', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
const res = this.res;
|
|
this.status = 200;
|
|
res.setHeader('Content-Type', 'text/html');
|
|
res.write('Hello');
|
|
setTimeout(function () {
|
|
res.end('Goodbye');
|
|
}, 0);
|
|
});
|
|
|
|
let errorCaught = false;
|
|
|
|
app.on('error', function (err) {
|
|
errorCaught = err;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(200)
|
|
.end(function (err) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
if (errorCaught) {
|
|
return done(errorCaught);
|
|
}
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should send the right body', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
const res = this.res;
|
|
this.status = 200;
|
|
res.setHeader('Content-Type', 'text/html');
|
|
res.write('Hello');
|
|
setTimeout(function () {
|
|
res.end('Goodbye');
|
|
}, 0);
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(200)
|
|
.expect('HelloGoodbye', done);
|
|
});
|
|
});
|
|
|
|
describe('when .body is missing', function () {
|
|
describe('with status=400', function () {
|
|
it('should respond with the associated status message', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 400;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(400)
|
|
.expect('Content-Length', 11)
|
|
.expect('Bad Request', done);
|
|
});
|
|
});
|
|
|
|
describe('with status=204', function () {
|
|
it('should respond without a body', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(204)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('with status=205', function () {
|
|
it('should respond without a body', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 205;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(205)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('with status=304', function () {
|
|
it('should respond without a body', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 304;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(304)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
// describe('with custom status=700', function(){
|
|
// it('should respond with the associated status message', function (done){
|
|
// const app = strapi.server();
|
|
// statuses['700'] = 'custom status';
|
|
//
|
|
// app.use(function *(){
|
|
// this.status = 700;
|
|
// });
|
|
//
|
|
// request(app.listen())
|
|
// .get('/')
|
|
// .expect(700)
|
|
// .expect('custom status')
|
|
// .end(function(err, res){
|
|
// if (err) {
|
|
// return done(err);
|
|
// }
|
|
// res.res.statusMessage.should.equal('custom status');
|
|
// done();
|
|
// });
|
|
// });
|
|
// });
|
|
|
|
describe('with custom statusMessage=ok', function () {
|
|
it('should respond with the custom status message', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 200;
|
|
this.message = 'ok';
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(200)
|
|
.expect('ok')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
res.res.statusMessage.should.equal('ok');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('with custom status without message', function () {
|
|
it('should respond with the status code number', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.res.statusCode = 701;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(701)
|
|
.expect('701', done);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when .body is a null', function () {
|
|
it('should respond 204 by default', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = null;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(204)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should respond 204 with status=200', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 200;
|
|
this.body = null;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(204)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should respond 205 with status=205', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 205;
|
|
this.body = null;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(205)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should respond 304 with status=304', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 304;
|
|
this.body = null;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(304)
|
|
.expect('')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
|
|
res.header.should.not.have.property('content-type');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when .body is a string', function () {
|
|
it('should respond', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = 'Hello';
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Hello', done);
|
|
});
|
|
});
|
|
|
|
describe('when .body is a Buffer', function () {
|
|
it('should respond', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = new Buffer('Hello');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Hello', done);
|
|
});
|
|
});
|
|
|
|
describe('when .body is a Stream', function () {
|
|
it('should respond', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = fs.createReadStream('package.json');
|
|
this.set('Content-Type', 'application/json; charset=utf-8');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Content-Type', 'application/json; charset=utf-8')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
const pkg = require('../../package');
|
|
res.should.not.have.header('Content-Length');
|
|
res.body.should.eql(pkg);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should strip content-length when overwriting', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = 'hello';
|
|
this.body = fs.createReadStream('package.json');
|
|
this.set('Content-Type', 'application/json; charset=utf-8');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Content-Type', 'application/json; charset=utf-8')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
const pkg = require('../../package');
|
|
res.should.not.have.header('Content-Length');
|
|
res.body.should.eql(pkg);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should keep content-length if not overwritten', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.length = fs.readFileSync('package.json').length;
|
|
this.body = fs.createReadStream('package.json');
|
|
this.set('Content-Type', 'application/json; charset=utf-8');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Content-Type', 'application/json; charset=utf-8')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
const pkg = require('../../package');
|
|
res.should.have.header('Content-Length');
|
|
res.body.should.eql(pkg);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should keep content-length if overwritten with the same stream', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.length = fs.readFileSync('package.json').length;
|
|
const stream = fs.createReadStream('package.json');
|
|
this.body = stream;
|
|
this.body = stream;
|
|
this.set('Content-Type', 'application/json; charset=utf-8');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Content-Type', 'application/json; charset=utf-8')
|
|
.end(function (err, res) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
const pkg = require('../../package');
|
|
res.should.have.header('Content-Length');
|
|
res.body.should.eql(pkg);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should handle errors', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.set('Content-Type', 'application/json; charset=utf-8');
|
|
this.body = fs.createReadStream('does not exist');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Content-Type', 'text/plain; charset=utf-8')
|
|
.expect(404)
|
|
.end(done);
|
|
});
|
|
|
|
it('should handle errors when no content status', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 204;
|
|
this.body = fs.createReadStream('does not exist');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
|
|
it('should handle all intermediate stream body errors', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = fs.createReadStream('does not exist');
|
|
this.body = fs.createReadStream('does not exist');
|
|
this.body = fs.createReadStream('does not exist');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(404, done);
|
|
});
|
|
});
|
|
|
|
describe('when .body is an Object', function () {
|
|
it('should respond with json', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.body = {
|
|
hello: 'world'
|
|
};
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect('Content-Type', 'application/json; charset=utf-8')
|
|
.expect('{"hello":"world"}', done);
|
|
});
|
|
});
|
|
|
|
describe('when an error occurs', function () {
|
|
it('should emit "error" on the app', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
throw new Error('boom');
|
|
});
|
|
|
|
app.on('error', function (err) {
|
|
err.message.should.equal('boom');
|
|
done();
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.end(function () {});
|
|
});
|
|
|
|
describe('with an .expose property', function () {
|
|
it('should expose the message', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
const err = new Error('sorry!');
|
|
err.status = 403;
|
|
err.expose = true;
|
|
throw err;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(403, 'sorry!')
|
|
.end(done);
|
|
});
|
|
});
|
|
|
|
describe('with a .status property', function () {
|
|
it('should respond with .status', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
const err = new Error('s3 explodes');
|
|
err.status = 403;
|
|
throw err;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(403, 'Forbidden')
|
|
.end(done);
|
|
});
|
|
});
|
|
|
|
it('should respond with 500', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
throw new Error('boom!');
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(500, 'Internal Server Error')
|
|
.end(done);
|
|
});
|
|
|
|
// it('should be catchable', function (done) {
|
|
// const app = strapi.server();
|
|
//
|
|
// app.use(function * (next) {
|
|
// try {
|
|
// yield next;
|
|
// this.body = 'Hello';
|
|
// } catch (err) {
|
|
// error = err;
|
|
// this.body = 'Got error';
|
|
// }
|
|
// });
|
|
//
|
|
// app.use(function * () {
|
|
// throw new Error('boom!');
|
|
// this.body = 'Oh no';
|
|
// });
|
|
//
|
|
// request(app.listen())
|
|
// .get('/')
|
|
// .expect(200, 'Got error')
|
|
// .end(done);
|
|
// });
|
|
});
|
|
|
|
describe('when status and body property', function () {
|
|
it('should 200', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 304;
|
|
this.body = 'hello';
|
|
this.status = 200;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(200)
|
|
.expect('hello', done);
|
|
});
|
|
|
|
it('should 204', function (done) {
|
|
const app = strapi.server();
|
|
|
|
app.use(function * () {
|
|
this.status = 200;
|
|
this.body = 'hello';
|
|
this.set('content-type', 'text/plain; charset=utf8');
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app.listen())
|
|
.get('/')
|
|
.expect(204)
|
|
.end(function (err, res) {
|
|
res.should.not.have.header('content-type');
|
|
done(err);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('app.context', function () {
|
|
const app1 = strapi.server();
|
|
app1.context.msg = 'hello';
|
|
const app2 = strapi.server();
|
|
|
|
it('should merge properties', function (done) {
|
|
app1.use(function * () {
|
|
assert.equal(this.msg, 'hello');
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app1.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
|
|
it('should not affect the original prototype', function (done) {
|
|
app2.use(function * () {
|
|
assert.equal(this.msg, undefined);
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app2.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
});
|
|
|
|
describe('app.request', function () {
|
|
const app1 = strapi.server();
|
|
app1.request.message = 'hello';
|
|
const app2 = strapi.server();
|
|
|
|
it('should merge properties', function (done) {
|
|
app1.use(function * () {
|
|
assert.equal(this.request.message, 'hello');
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app1.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
|
|
it('should not affect the original prototype', function (done) {
|
|
app2.use(function * () {
|
|
assert.equal(this.request.message, undefined);
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app2.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
});
|
|
|
|
describe('app.response', function () {
|
|
const app1 = strapi.server();
|
|
app1.response.msg = 'hello';
|
|
const app2 = strapi.server();
|
|
|
|
it('should merge properties', function (done) {
|
|
app1.use(function * () {
|
|
assert.equal(this.response.msg, 'hello');
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app1.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
|
|
it('should not affect the original prototype', function (done) {
|
|
app2.use(function * () {
|
|
assert.equal(this.response.msg, undefined);
|
|
this.status = 204;
|
|
});
|
|
|
|
request(app2.listen())
|
|
.get('/')
|
|
.expect(204, done);
|
|
});
|
|
});
|