TheThing
/
flaska
1
0
Fork 0
Code Issues Pull Requests Projects Releases 17 Wiki Activity

Update eltro, clean up a few tests
continuous-integration/appveyor/branch AppVeyor build succeeded Details

master
Jonatan Nilsson 2022-07-04 13:24:19 +00:00
parent e9c600b869
commit baf2d896c1
4 changed files with 321 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
package.json
View File

@ -39,7 +39,7 @@
},
"homepage": "https://git.nfp.is/TheThing/flaska/#readme",
"devDependencies": {
"eltro": "^1.2.3",
"eltro": "^1.3.2",
"formidable": "^1.2.2"
},
"files": [

4
test/flaska.api.test.mjs
View File

@ -80,8 +80,7 @@ t.describe('#constructor', function() {
flaska._before[0](ctx)
let keys = Object.keys(defaultHeaders)
console.log(Object.keys(ctx.headers).sort())
console.log(keys.sort())
assert.strictEqual(Object.keys(ctx.headers).length, keys.length + 1)
for (let key of keys) {
assert.strictEqual(ctx.headers[key], defaultHeaders[key])
@ -946,6 +945,7 @@ t.describe('#listenAsync()', function() {
checkIp = ip
cb()
})
let flaska = new Flaska({}, testFaker)
assert.ok(flaska.requestStart)
flaska.requestStart = function() {

401
test/flaska.in.test.mjs
View File

@ -19,39 +19,32 @@ t.describe('#requestStart()', function() {
flaska.onreserror(onResError)
flaska.requestEnded = onEnded
flaska.requestEnd = function(err, ctx) {
try {
assert.ok(err)
assert.strictEqual(assertReq.on.callCount, 1)
assert.strictEqual(assertRes.on.callCount, 2)
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.strictEqual(assertReq.on.callCount, 1)
assert.strictEqual(assertRes.on.callCount, 2)
assert.strictEqual(assertRes.on.firstCall[0], 'error')
assert.strictEqual(typeof(assertRes.on.firstCall[1]), 'function')
assertRes.on.firstCall[1](assertErrorTwo, ctx)
assert.strictEqual(onResError.callCount, 1)
assert.strictEqual(onResError.firstCall[0], assertErrorTwo)
assert.strictEqual(onResError.firstCall[1], ctx)
assert.strictEqual(assertRes.on.secondCall[0], 'finish')
assert.strictEqual(typeof(assertRes.on.secondCall[1]), 'function')
assert.strictEqual(onEnded.callCount, 0)
assertRes.on.secondCall[1]()
assert.strictEqual(onEnded.callCount, 1)
assert.strictEqual(onEnded.firstCall[0], ctx)
assert.strictEqual(assertRes.on.firstCall[0], 'error')
assert.strictEqual(typeof(assertRes.on.firstCall[1]), 'function')
assertRes.on.firstCall[1](assertErrorTwo, ctx)
assert.strictEqual(onResError.callCount, 1)
assert.strictEqual(onResError.firstCall[0], assertErrorTwo)
assert.strictEqual(onResError.firstCall[1], ctx)
assert.strictEqual(assertRes.on.secondCall[0], 'finish')
assert.strictEqual(typeof(assertRes.on.secondCall[1]), 'function')
assert.strictEqual(onEnded.callCount, 0)
assertRes.on.secondCall[1]()
assert.strictEqual(onEnded.callCount, 1)
assert.strictEqual(onEnded.firstCall[0], ctx)
assert.strictEqual(assertReq.on.firstCall[0], 'error')
assert.strictEqual(typeof(assertReq.on.firstCall[1]), 'function')
assertReq.on.firstCall[1](assertErrorOne, ctx)
assert.strictEqual(onReqError.callCount, 1)
assert.strictEqual(onReqError.firstCall[0], assertErrorOne)
assert.strictEqual(onReqError.firstCall[1], ctx)
// Test abort and close
cb()
} catch (err) { cb(err) }
}
assert.strictEqual(assertReq.on.firstCall[0], 'error')
assert.strictEqual(typeof(assertReq.on.firstCall[1]), 'function')
assertReq.on.firstCall[1](assertErrorOne, ctx)
assert.strictEqual(onReqError.callCount, 1)
assert.strictEqual(onReqError.firstCall[0], assertErrorOne)
assert.strictEqual(onReqError.firstCall[1], ctx)
})
flaska._beforeCompiled = function(ctx) {
throw new Error()
}
@ -65,18 +58,13 @@ t.describe('#requestStart()', function() {
const assertRes = createRes({ b: 2 })
let flaska = new Flaska({}, faker)
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.strictEqual(err, assertError)
assert.deepStrictEqual(ctx.state, {})
assert.strictEqual(ctx.req, assertReq)
assert.strictEqual(ctx.res, assertRes)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.strictEqual(err, assertError)
assert.deepStrictEqual(ctx.state, {})
assert.strictEqual(ctx.req, assertReq)
assert.strictEqual(ctx.res, assertRes)
})
flaska._beforeCompiled = function(ctx) {
assert.strictEqual(ctx.req, assertReq)
assert.strictEqual(ctx.res, assertRes)
@ -99,18 +87,13 @@ t.describe('#requestStart()', function() {
return Promise.resolve().then(function() { return Promise.reject(assertError) })
}
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.strictEqual(err, assertError)
assert.deepStrictEqual(ctx.state, {})
assert.strictEqual(ctx.req, assertReq)
assert.strictEqual(ctx.res, assertRes)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.strictEqual(err, assertError)
assert.deepStrictEqual(ctx.state, {})
assert.strictEqual(ctx.req, assertReq)
assert.strictEqual(ctx.res, assertRes)
})
flaska.requestStart(assertReq, assertRes)
})
@ -132,39 +115,35 @@ t.describe('#requestStart()', function() {
}
}
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
flaska.requestEnd = cb.finish(function(err, ctx) {
try {
assert.ok(err)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx.url, assertPath)
assert.strictEqual(ctx.search, assertSearch)
assert.strictEqual(ctx.method, assertMethod)
assert.strictEqual(ctx.status, 200)
assert.strictEqual(ctx.body, null)
assert.strictEqual(ctx.type, null)
assert.strictEqual(ctx.length, null)
assert.strictEqual(ctx.log, assertLog)
assert.ok(ctx.query)
assert.ok(ctx.query.get)
assert.ok(ctx.query.set)
assert.ok(ctx.query.delete)
assert.deepEqual(
Object.keys(ctx.headers).sort(),
['Server','X-Content-Type-Options','Content-Security-Policy','Cross-Origin-Opener-Policy','Cross-Origin-Resource-Policy','Cross-Origin-Embedder-Policy','Date'].sort()
)
assert.ok(err)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx.url, assertPath)
assert.strictEqual(ctx.search, assertSearch)
assert.strictEqual(ctx.method, assertMethod)
assert.strictEqual(ctx.status, 200)
assert.strictEqual(ctx.body, null)
assert.strictEqual(ctx.type, null)
assert.strictEqual(ctx.length, null)
assert.strictEqual(ctx.log, assertLog)
assert.ok(ctx.query)
assert.ok(ctx.query.get)
assert.ok(ctx.query.set)
assert.ok(ctx.query.delete)
assert.deepEqual(
Object.keys(ctx.headers).sort(),
['Server','X-Content-Type-Options','Content-Security-Policy','Cross-Origin-Opener-Policy','Cross-Origin-Resource-Policy','Cross-Origin-Embedder-Policy','Date'].sort()
)
assert.strictEqual(ctx.headers['Server'], 'Flaska')
assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'`)
assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
assert.ok(new Date(ctx.headers['Date']).getDate())
cb()
} catch (err) { cb(err) }
}
assert.strictEqual(ctx.headers['Server'], 'Flaska')
assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'`)
assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
assert.ok(new Date(ctx.headers['Date']).getDate())
})
flaska.requestStart(createReq({
url: assertPath + assertSearch,
@ -189,21 +168,16 @@ t.describe('#requestStart()', function() {
}
}
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.strictEqual(err, assertError)
let keys = Object.keys(defaultHeaders)
assert.strictEqual(Object.keys(ctx.headers).length, keys.length + 1)
for (let key of keys) {
assert.strictEqual(ctx.headers[key], defaultHeaders[key])
}
assert.ok(ctx.headers['Date'])
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.strictEqual(err, assertError)
let keys = Object.keys(defaultHeaders)
assert.strictEqual(Object.keys(ctx.headers).length, keys.length + 1)
for (let key of keys) {
assert.strictEqual(ctx.headers[key], defaultHeaders[key])
}
assert.ok(ctx.headers['Date'])
})
flaska.requestStart(createReq({
url: '/',
@ -216,9 +190,13 @@ t.describe('#requestStart()', function() {
const assertMethod = 'test'
const assertPath = '/test/me'
const assertSearch = '?asdf=test'
let calledBefore = false
let flaska = new Flaska({}, faker)
flaska.compile()
flaska._beforeAsyncCompiled = function() { return Promise.resolve() }
flaska._beforeAsyncCompiled = function() {
calledBefore = true
return Promise.resolve()
}
flaska.routers.test = {
match: function(path) {
@ -227,18 +205,14 @@ t.describe('#requestStart()', function() {
}
}
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx.url, assertPath)
assert.strictEqual(ctx.search, assertSearch)
assert.strictEqual(ctx.method, assertMethod)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(calledBefore)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx.url, assertPath)
assert.strictEqual(ctx.search, assertSearch)
assert.strictEqual(ctx.method, assertMethod)
})
flaska.requestStart(createReq({
url: assertPath + assertSearch,
@ -269,18 +243,13 @@ t.describe('#requestStart()', function() {
throw assertError
}
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkMiddleCtx)
assert.strictEqual(ctx.params, assertParams)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkMiddleCtx)
assert.strictEqual(ctx.params, assertParams)
})
flaska.requestStart(createReq({
url: '',
@ -301,17 +270,12 @@ t.describe('#requestStart()', function() {
flaska.get('/:id', handler)
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
})
flaska.requestStart(createReq({
url: '/test',
@ -331,16 +295,12 @@ t.describe('#requestStart()', function() {
flaska.get('/test', function() { throw new Error('should not be called') })
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err) return cb(err)
try {
assert.ok(ctx)
assert.strictEqual(on404Error.callCount, 1)
assert.strictEqual(on404Error.firstCall[0], ctx)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.notOk(err)
assert.ok(ctx)
assert.strictEqual(on404Error.callCount, 1)
assert.strictEqual(on404Error.firstCall[0], ctx)
})
flaska.requestStart(createReq({
url: '/nope',
@ -361,17 +321,11 @@ t.describe('#requestStart()', function() {
flaska.get('/test', function() { throw new Error('should not be called') })
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(ctx, checkCtx)
assert.strictEqual(err, assertError)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.strictEqual(err, assertError)
assert.ok(ctx)
assert.strictEqual(ctx, checkCtx)
})
flaska.requestStart(createReq({
url: '/nope',
@ -391,17 +345,11 @@ t.describe('#requestStart()', function() {
flaska.get('/test', function() { throw new Error('should not be called') })
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(ctx, checkCtx)
assert.strictEqual(err, assertError)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.strictEqual(err, assertError)
assert.ok(ctx)
assert.strictEqual(ctx, checkCtx)
})
flaska.requestStart(createReq({
url: '/nope',
@ -421,17 +369,11 @@ t.describe('#requestStart()', function() {
flaska.get('/test', middles, function() { throw new Error('should not be called') })
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(ctx, checkCtx)
assert.strictEqual(err, assertError)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.strictEqual(err, assertError)
assert.ok(ctx)
assert.strictEqual(ctx, checkCtx)
})
flaska.requestStart(createReq({
url: '/test',
@ -453,14 +395,11 @@ t.describe('#requestStart()', function() {
throw new Error('should not be called')
}
flaska.requestEnd = function(err, ctx) {
try {
assert.notOk(err)
assert.ok(ctx)
assert.strictEqual(ctx.body, assertBody)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.notOk(err)
assert.ok(ctx)
assert.strictEqual(ctx.body, assertBody)
})
flaska.requestStart(createReq({
url: '/test/something/here',
@ -485,16 +424,11 @@ t.describe('#requestStart()', function() {
return Promise.resolve().then(function() { return Promise.reject(assertError) })
}
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
})
flaska.requestStart(createReq({
url: '',
@ -515,17 +449,12 @@ t.describe('#requestStart()', function() {
flaska.get('/:id', [function() { return Promise.resolve() }], handler)
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
})
flaska.requestStart(createReq({
url: '/test',
@ -546,17 +475,12 @@ t.describe('#requestStart()', function() {
flaska.get('/:id', [function() { return Promise.resolve() }], handler)
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
})
flaska.requestStart(createReq({
url: '/test',
@ -585,15 +509,12 @@ t.describe('#requestStart()', function() {
flaska.get('/::path', [middle], handler)
flaska.compile()
flaska.requestEnd = function(err, ctx) {
try {
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.notOk(err)
assert.ok(ctx)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.state, assertState)
cb()
} catch (err) { cb(err) }
}
})
flaska.requestStart(createReq({
url: '/test/something/here',
@ -616,17 +537,12 @@ t.describe('#requestStart()', function() {
flaska.get('/:id', handler)
flaska.compile()
flaska.requestEnd = function(err, ctx) {
if (err && err !== assertError) return cb(err)
try {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.ok(err)
assert.ok(ctx)
assert.strictEqual(err, assertError)
assert.strictEqual(ctx, checkHandlerCtx)
})
flaska.requestStart(createReq({
url: '/test',
@ -651,14 +567,11 @@ t.describe('#requestStart()', function() {
throw new Error('should not be called')
}
flaska.requestEnd = function(err, ctx) {
try {
assert.notOk(err)
assert.ok(ctx)
assert.strictEqual(ctx.body, assertBody)
cb()
} catch (err) { cb(err) }
}
flaska.requestEnd = cb.finish(function(err, ctx) {
assert.notOk(err)
assert.ok(ctx)
assert.strictEqual(ctx.body, assertBody)
})
flaska.requestStart(createReq({
url: '/test/something/here',

366
test/flaska.out.test.mjs
View File

@ -12,20 +12,17 @@ t.describe('#requestEnd()', function() {
const assertStatus = 501
// Calculated manually just in case
const assertBodyLength = 7
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
assert.ok(body)
assert.strictEqual(body, '{"a":1}')
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
assert.ok(body)
assert.strictEqual(body, '{"a":1}')
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({}, onFinish)
let flaska = new Flaska({}, fakerHttp, fakeStream)
@ -43,14 +40,11 @@ t.describe('#requestEnd()', function() {
const assertErrorNotSeen = new Error('should not be seen')
const assertError = new Error('test')
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, 500)
assert.strictEqual(ctx.body.status, 500)
assert.strictEqual(ctx.body.message, 'Internal Server Error')
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, 500)
assert.strictEqual(ctx.body.status, 500)
assert.strictEqual(ctx.body.message, 'Internal Server Error')
})
const ctx = createCtx({}, onFinish)
let flaska = new Flaska({}, fakerHttp, fakeStream)
@ -70,26 +64,23 @@ t.describe('#requestEnd()', function() {
// Calculated manually just in case
const assertBodyLength = 7
const assertBody = { a: 1 }
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
if (method === 'GET') {
assert.ok(body)
assert.strictEqual(body, '{"a":1}')
} else {
assert.notOk(body)
}
if (method === 'GET') {
assert.ok(body)
assert.strictEqual(body, '{"a":1}')
} else {
assert.notOk(body)
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
method: method,
status: assertStatus,
@ -104,21 +95,18 @@ t.describe('#requestEnd()', function() {
// Calculated manually just in case
const assertBodyLength = 0
const assertBody = null
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, 204)
assert.strictEqual(ctx.body, assertBody)
assert.notOk(ctx.headers['Content-Type'])
assert.notOk(ctx.headers['Content-Length'])
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, 204)
assert.strictEqual(ctx.body, assertBody)
assert.notOk(ctx.headers['Content-Type'])
assert.notOk(ctx.headers['Content-Length'])
assert.strictEqual(body, undefined)
assert.strictEqual(body, undefined)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
method: method,
status: 200,
@ -133,21 +121,18 @@ t.describe('#requestEnd()', function() {
const assertStatus = 202
// Calculated manually just in case
const assertBody = null
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.notOk(ctx.headers['Content-Type'])
assert.strictEqual(ctx.headers['Content-Length'], 0)
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.notOk(ctx.headers['Content-Type'])
assert.strictEqual(ctx.headers['Content-Length'], 0)
assert.strictEqual(body, undefined)
assert.strictEqual(body, undefined)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
method: method,
status: assertStatus,
@ -163,26 +148,23 @@ t.describe('#requestEnd()', function() {
// Calculated manually just in case
const assertBodyLength = 4
const assertBody = 'eða'
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
if (method === 'GET') {
assert.ok(body)
assert.strictEqual(body, assertBody)
} else {
assert.notOk(body)
}
if (method === 'GET') {
assert.ok(body)
assert.strictEqual(body, assertBody)
} else {
assert.notOk(body)
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
method: method,
status: assertStatus,
@ -198,25 +180,22 @@ t.describe('#requestEnd()', function() {
// Calculated manually just in case
const assertBodyLength = 7
const assertBody = 4214124
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
if (method === 'GET') {
assert.ok(body)
assert.strictEqual(body, assertBody.toString())
} else {
assert.notOk(body)
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
if (method === 'GET') {
assert.ok(body)
assert.strictEqual(body, assertBody.toString())
} else {
assert.notOk(body)
}
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
method: method,
status: assertStatus,
@ -242,22 +221,19 @@ t.describe('#requestEnd()', function() {
let body = new FileResponse()
let assertBody = { pipe: function() {} }
let onFinish = function(source, target, callback) {
try {
assert.ok(assertHandle.called)
assert.ok(ctx.res.writeHead)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(source, assertBody)
assert.strictEqual(target, ctx.res)
assert.strictEqual(typeof(callback), 'function')
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
assert.strictEqual(ctx.headers['Content-Type'], assertContentType)
assert.strictEqual(ctx.headers['Content-Length'], assertContentLength)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(source, target, callback) {
assert.ok(assertHandle.called)
assert.ok(ctx.res.writeHead)
assert.strictEqual(ctx.body, assertBody)
assert.strictEqual(source, assertBody)
assert.strictEqual(target, ctx.res)
assert.strictEqual(typeof(callback), 'function')
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
assert.strictEqual(ctx.headers['Content-Type'], assertContentType)
assert.strictEqual(ctx.headers['Content-Length'], assertContentLength)
})
const ctx = createCtx({
})
ctx.body = body
@ -278,19 +254,16 @@ t.describe('#requestEnd()', function() {
const assertType = 'herp/derp'
const assertBody = { pipe: function() {} }
let onFinish = function(source, target, callback) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.headers['Content-Type'], assertType)
assert.strictEqual(source, assertBody)
assert.strictEqual(target, ctx.res)
assert.strictEqual(typeof(callback), 'function')
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(source, target, callback) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.headers['Content-Type'], assertType)
assert.strictEqual(source, assertBody)
assert.strictEqual(target, ctx.res)
assert.strictEqual(typeof(callback), 'function')
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
status: assertStatus,
})
@ -315,20 +288,18 @@ t.describe('#requestEnd()', function() {
})
let body = new FileResponse()
let onFinish = function(body) {
try {
assert.ok(assertHandle.called)
assert.ok(ctx.res.writeHead)
assert.strictEqual(ctx.body, null)
assert.notOk(body)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
assert.strictEqual(ctx.headers['Content-Type'], assertContentType)
assert.strictEqual(ctx.headers['Content-Length'], assertContentLength)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(body) {
assert.ok(assertHandle.called)
assert.ok(ctx.res.writeHead)
assert.strictEqual(ctx.body, null)
assert.notOk(body)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
assert.strictEqual(ctx.headers['Content-Type'], assertContentType)
assert.strictEqual(ctx.headers['Content-Length'], assertContentLength)
})
const ctx = createCtx({
method: method,
}, onFinish)
@ -349,20 +320,17 @@ t.describe('#requestEnd()', function() {
const assertType = 'herp/derp'
const assertBody = { pipe: function() {}, destroy: stub() }
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.headers['Content-Type'], assertType)
assert.notOk(ctx.headers['Content-Length'])
assert.notOk(body)
assert.ok(assertBody.destroy.called)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.headers['Content-Type'], assertType)
assert.notOk(ctx.headers['Content-Length'])
assert.notOk(body)
assert.ok(assertBody.destroy.called)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
method: method,
status: assertStatus,
@ -405,17 +373,14 @@ t.describe('#requestEnd()', function() {
const assertStatus = 209
const assertBody = 'test'
const assertType = 'something/else'
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.headers['Content-Type'], assertType)
assert.strictEqual(body, assertBody)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.headers['Content-Type'], assertType)
assert.strictEqual(body, assertBody)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({
status: assertStatus,
body: assertBody,
@ -427,18 +392,15 @@ t.describe('#requestEnd()', function() {
})
t.test('call pipe should have default type', function(cb) {
let onFinish = function(source, target) {
try {
assert.strictEqual(ctx.status, 200)
assert.strictEqual(ctx.headers['Content-Type'], 'application/octet-stream')
assert.strictEqual(source, ctx.body)
assert.strictEqual(target, ctx.res)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(source, target) {
assert.strictEqual(ctx.status, 200)
assert.strictEqual(ctx.headers['Content-Type'], 'application/octet-stream')
assert.strictEqual(source, ctx.body)
assert.strictEqual(target, ctx.res)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({})
ctx.body = { pipe: function() {} }
fakeStream.pipeline = onFinish
@ -456,18 +418,15 @@ t.describe('#requestEnd()', function() {
tests.forEach(function(test) {
t.test(`call pipe with file extension ${test[0]} should mimetype ${test[1]}`, function(cb) {
let onFinish = function(source, target) {
try {
assert.strictEqual(ctx.status, 200)
assert.strictEqual(ctx.headers['Content-Type'], test[1])
assert.strictEqual(source, ctx.body)
assert.strictEqual(target, ctx.res)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(source, target) {
assert.strictEqual(ctx.status, 200)
assert.strictEqual(ctx.headers['Content-Type'], test[1])
assert.strictEqual(source, ctx.body)
assert.strictEqual(target, ctx.res)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
})
const ctx = createCtx({})
ctx.body = { pipe: function() {}, path: './bla/test/temp.' + test[0] }
fakeStream.pipeline = onFinish
@ -495,17 +454,14 @@ t.describe('#requestEnd()', function() {
const assertStatus = status
const assertNotBody = 'test'
const assertNotType = 'something/else'
let onFinish = function(body) {
try {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.res.setHeader.callCount, 0)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
assert.notOk(body)
cb()
} catch (err) { cb(err) }
}
let onFinish = cb.finish(function(body) {
assert.strictEqual(ctx.status, assertStatus)
assert.strictEqual(ctx.res.setHeader.callCount, 0)
assert.ok(ctx.res.writeHead.called)
assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
assert.notOk(body)
})
const ctx = createCtx({
status: assertStatus,
body: assertNotBody,