1099 lines
39 KiB
JavaScript
1099 lines
39 KiB
JavaScript
import { Eltro as t, assert, stub, spy } from 'eltro'
|
|
import { Flaska, HttpError } from '../flaska.mjs'
|
|
import { createCtx, fakeHttp } from './helper.mjs'
|
|
|
|
const faker = fakeHttp()
|
|
|
|
t.describe('#constructor', function() {
|
|
t.test('should be able to override the http', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.strictEqual(flaska.http, faker)
|
|
})
|
|
|
|
t.test('it should have all the common verbs', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.ok(flaska.get)
|
|
assert.strictEqual(typeof(flaska.get), 'function')
|
|
assert.ok(flaska.post)
|
|
assert.strictEqual(typeof(flaska.post), 'function')
|
|
assert.ok(flaska.put)
|
|
assert.strictEqual(typeof(flaska.put), 'function')
|
|
assert.ok(flaska.delete)
|
|
assert.strictEqual(typeof(flaska.delete), 'function')
|
|
assert.ok(flaska.options)
|
|
assert.strictEqual(typeof(flaska.options), 'function')
|
|
assert.ok(flaska.patch)
|
|
assert.strictEqual(typeof(flaska.patch), 'function')
|
|
})
|
|
|
|
t.test('the verbs GET and HEAD should be identical', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.ok(flaska.get)
|
|
assert.strictEqual(typeof(flaska.get), 'function')
|
|
assert.notOk(flaska.head)
|
|
assert.ok(flaska.routers['HEAD'])
|
|
assert.strictEqual(flaska.routers['GET'], flaska.routers['HEAD'])
|
|
})
|
|
|
|
t.test('should have before default header generator', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.strictEqual(flaska._before.length, 1)
|
|
|
|
let ctx = {}
|
|
|
|
flaska._before[0](ctx)
|
|
|
|
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())
|
|
|
|
assert.strictEqual(flaska._after.length, 0)
|
|
})
|
|
|
|
t.test('should have before ready setting headers on context if defaultHeaders is specified', function() {
|
|
const defaultHeaders = {
|
|
'Server': 'nginx/1.16.1',
|
|
'Content-Type': 'applicat"ion/json; charset=utf-8',
|
|
'Content-Length': '1646',
|
|
'Connection': 'keep-alive',
|
|
'vary': 'Origin',
|
|
'Link': 'Link goes here',
|
|
'X-Frame-Options': 'DENY',
|
|
'X-Content-Type-Options': 'nosniff',
|
|
}
|
|
let flaska = new Flaska({
|
|
defaultHeaders: defaultHeaders,
|
|
}, faker)
|
|
assert.strictEqual(flaska._before.length, 1)
|
|
|
|
let ctx = {}
|
|
|
|
flaska._before[0](ctx)
|
|
|
|
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'])
|
|
|
|
assert.strictEqual(flaska._after.length, 0)
|
|
})
|
|
|
|
t.test('should have before ready setting headers on context if appendHeaders is specified', function() {
|
|
const appendHeaders = {
|
|
'Server': 'nginx/1.16.1',
|
|
'Herp': 'Derp',
|
|
}
|
|
let flaska = new Flaska({
|
|
appendHeaders: appendHeaders,
|
|
}, faker)
|
|
assert.strictEqual(flaska._before.length, 1)
|
|
|
|
let ctx = {}
|
|
|
|
flaska._before[0](ctx)
|
|
|
|
assert.deepEqual(
|
|
Object.keys(ctx.headers).sort(),
|
|
['Server', 'Herp', 'X-Content-Type-Options','Content-Security-Policy','Cross-Origin-Opener-Policy','Cross-Origin-Resource-Policy','Cross-Origin-Embedder-Policy','Date'].sort()
|
|
)
|
|
|
|
assert.notStrictEqual(ctx.headers['Server'], 'Flaska')
|
|
assert.strictEqual(ctx.headers['Server'], appendHeaders.Server)
|
|
assert.strictEqual(ctx.headers['Herp'], 'Derp')
|
|
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())
|
|
|
|
assert.strictEqual(flaska._after.length, 0)
|
|
})
|
|
})
|
|
|
|
t.describe('#_nonce', function() {
|
|
t.test('should support nonce parameter with cached pre-filled entries', function() {
|
|
let flaska = new Flaska({
|
|
nonce: ['script-src', 'style-src'],
|
|
}, faker)
|
|
|
|
assert.ok(flaska._nonces)
|
|
assert.strictEqual(flaska._noncesIndex + 1, flaska._nonces.length)
|
|
assert.strictEqual(flaska._nonces.length, 25)
|
|
assert.ok(flaska._nonces[flaska._noncesIndex])
|
|
|
|
//Check they're all unique
|
|
let set = new Set()
|
|
flaska._nonces.forEach(function(entry) {
|
|
set.add(entry)
|
|
})
|
|
assert.strictEqual(set.size, flaska._nonces.length)
|
|
|
|
let ctx = createCtx()
|
|
|
|
assert.notOk(ctx.state.nonce)
|
|
|
|
let oldIndex = flaska._noncesIndex
|
|
|
|
flaska._before[0](ctx)
|
|
|
|
assert.ok(ctx.state.nonce)
|
|
assert.strictEqual(flaska._noncesIndex, oldIndex - 1)
|
|
assert.strictEqual(flaska._nonces[oldIndex], ctx.state.nonce)
|
|
|
|
|
|
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' 'nonce-${ctx.state.nonce}'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
|
|
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())
|
|
})
|
|
|
|
t.test('should always return nonce values even if it runs out in cache', function() {
|
|
let flaska = new Flaska({
|
|
nonce: ['script-src'],
|
|
nonceCacheLength: 5,
|
|
}, faker)
|
|
let ctx = createCtx()
|
|
|
|
for (let i = 0; i < 5; i++) {
|
|
let nextNonce = flaska._nonces[flaska._noncesIndex]
|
|
flaska._before[0](ctx)
|
|
assert.strictEqual(ctx.state.nonce, nextNonce)
|
|
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'; script-src 'nonce-${ctx.state.nonce}'`)
|
|
}
|
|
|
|
assert.notOk(flaska._nonces[flaska._noncesIndex])
|
|
|
|
flaska._before[0](ctx)
|
|
|
|
assert.notOk(flaska._nonces[flaska._noncesIndex])
|
|
assert.ok(ctx.state.nonce)
|
|
|
|
for (let i = 0; i < flaska._nonces.length; i++) {
|
|
assert.notStrictEqual(ctx.state.nonce, flaska._nonces[i])
|
|
}
|
|
|
|
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'; script-src 'nonce-${ctx.state.nonce}'`)
|
|
})
|
|
|
|
t.test('should have after that regenerates lost hashes', function() {
|
|
let flaska = new Flaska({
|
|
nonce: ['script-src'],
|
|
nonceCacheLength: 5,
|
|
}, faker)
|
|
let ctx = createCtx()
|
|
|
|
assert.strictEqual(flaska._after.length, 1)
|
|
|
|
//Check they're all unique
|
|
let set = new Set()
|
|
flaska._nonces.forEach(function(entry) {
|
|
set.add(entry)
|
|
})
|
|
assert.strictEqual(set.size, 5)
|
|
|
|
flaska._before[0](ctx)
|
|
flaska._before[0](ctx)
|
|
flaska._before[0](ctx)
|
|
|
|
assert.strictEqual(flaska._noncesIndex, 1)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 2)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 6)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 3)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 7)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 4)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 8)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 4)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 8)
|
|
})
|
|
|
|
t.test('after should not generate keys outside range', function() {
|
|
let flaska = new Flaska({
|
|
nonce: ['script-src'],
|
|
nonceCacheLength: 2,
|
|
}, faker)
|
|
let ctx = createCtx()
|
|
|
|
assert.strictEqual(flaska._after.length, 1)
|
|
|
|
//Check they're all unique
|
|
let set = new Set()
|
|
flaska._nonces.forEach(function(entry) {
|
|
set.add(entry)
|
|
})
|
|
assert.strictEqual(set.size, 2)
|
|
|
|
flaska._before[0](ctx)
|
|
flaska._before[0](ctx)
|
|
|
|
assert.strictEqual(flaska._noncesIndex, -1)
|
|
|
|
flaska._before[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, -2)
|
|
set.add(ctx.state.nonce)
|
|
assert.strictEqual(set.size, 3)
|
|
|
|
flaska._before[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, -3)
|
|
set.add(ctx.state.nonce)
|
|
assert.strictEqual(set.size, 4)
|
|
|
|
flaska._before[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, -4)
|
|
set.add(ctx.state.nonce)
|
|
assert.strictEqual(set.size, 5)
|
|
|
|
assert.strictEqual(Object.keys(flaska._nonces).length, 2)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 0)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 6)
|
|
assert.strictEqual(Object.keys(flaska._nonces).length, 2)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 1)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 7)
|
|
assert.strictEqual(Object.keys(flaska._nonces).length, 2)
|
|
|
|
flaska._after[0](ctx)
|
|
assert.strictEqual(flaska._noncesIndex, 1)
|
|
set.add(flaska._nonces[flaska._noncesIndex])
|
|
assert.strictEqual(set.size, 7)
|
|
assert.strictEqual(Object.keys(flaska._nonces).length, 2)
|
|
})
|
|
})
|
|
|
|
t.describe('#log', function() {
|
|
t.test('default have a logger valid', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.strictEqual(typeof(flaska.log.error), 'function')
|
|
assert.strictEqual(typeof(flaska.log.info), 'function')
|
|
assert.strictEqual(typeof(flaska.log.warn), 'function')
|
|
})
|
|
|
|
t.test('allow overwriting in options', function() {
|
|
const assertFunction = function() { return 1 }
|
|
let flaska = new Flaska({ log: {
|
|
error: assertFunction,
|
|
info: assertFunction,
|
|
warn: assertFunction,
|
|
debug: assertFunction,
|
|
} }, faker)
|
|
assert.strictEqual(flaska.log.error, assertFunction)
|
|
assert.strictEqual(flaska.log.info, assertFunction)
|
|
assert.strictEqual(flaska.log.warn, assertFunction)
|
|
assert.strictEqual(flaska.log.debug, assertFunction)
|
|
})
|
|
})
|
|
|
|
let specialHandlers = ['on404', 'onerror', 'onreqerror', 'onreserror']
|
|
|
|
specialHandlers.forEach(function(type) {
|
|
t.describe(`#${type}()`, function() {
|
|
t.test('exist', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.strictEqual(typeof(flaska[type]), 'function')
|
|
})
|
|
|
|
t.test('validate handler', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.throws(function() { flaska[type]() }, /[Ff]unction/)
|
|
assert.throws(function() { flaska[type]('asdf') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska[type]('123') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska[type]([]) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska[type]({}) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska[type](1234) }, /[Ff]unction/)
|
|
})
|
|
|
|
if (type !== 'on404') {
|
|
t.test('should call ctx.log.error correctly', function() {
|
|
const assertError = new Error('Samuraism')
|
|
let flaska = new Flaska({}, faker)
|
|
let ctx = createCtx()
|
|
flaska['_' + type](assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
})
|
|
}
|
|
|
|
if (type === 'onreqerror') {
|
|
t.test('default sends 400 immediately', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
let ctx = createCtx()
|
|
flaska['_' + type](new Error(), ctx)
|
|
assert.strictEqual(ctx.res.statusCode, 400)
|
|
assert.strictEqual(ctx.res.end.callCount, 1)
|
|
assert.strictEqual(ctx.res.end.firstCall.length, 0)
|
|
})
|
|
}
|
|
|
|
t.test('register it into flaska', function() {
|
|
const assertFunction = function() { return true }
|
|
let flaska = new Flaska({}, faker)
|
|
flaska[type](assertFunction)
|
|
assert.strictEqual(flaska['_' + type], assertFunction)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('_on404', function() {
|
|
t.test('default valid handling of context', function() {
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska._on404(ctx)
|
|
assert.strictEqual(ctx.status, 404)
|
|
assert.deepStrictEqual(ctx.body, {
|
|
status: 404,
|
|
message: 'Not Found',
|
|
})
|
|
})
|
|
|
|
t.test('should do nothing if body is not null', function() {
|
|
const assertBody = { a: 1 }
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
|
|
ctx.body = assertBody
|
|
flaska._on404(ctx)
|
|
assert.strictEqual(ctx.status, 200)
|
|
assert.strictEqual(ctx.body, assertBody)
|
|
})
|
|
|
|
t.test('should do nothing if body is null but status is 204', function() {
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
|
|
ctx.status = 204
|
|
ctx.body = null
|
|
flaska._on404(ctx)
|
|
assert.strictEqual(ctx.status, 204)
|
|
assert.strictEqual(ctx.body, null)
|
|
})
|
|
})
|
|
|
|
t.describe('_onerror', function() {
|
|
t.test('a valid function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.strictEqual(typeof(flaska._onerror), 'function')
|
|
})
|
|
|
|
t.test('default valid handling of context', function() {
|
|
const assertError = new Error('should not be seen')
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, 500)
|
|
assert.deepStrictEqual(ctx.body, {
|
|
status: 500,
|
|
message: 'Internal Server Error',
|
|
})
|
|
})
|
|
|
|
t.test('default valid handling of HttpError', function() {
|
|
const assertStatus = 431
|
|
const assertBody = { a: 1 }
|
|
const assertError = new HttpError(assertStatus, 'should not be seen', assertBody)
|
|
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, assertStatus)
|
|
assert.strictEqual(ctx.body, assertBody)
|
|
})
|
|
|
|
t.test('default valid handling of HttpError with no body', function() {
|
|
const assertStatus = 413
|
|
const assertError = new HttpError(assertStatus, 'should not be seen')
|
|
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, assertStatus)
|
|
assert.deepStrictEqual(ctx.body, {
|
|
status: assertStatus,
|
|
message: 'Payload Too Large',
|
|
})
|
|
})
|
|
|
|
t.test('default valid handling of HttpError with missing status message', function() {
|
|
const assertStatus = 432
|
|
const assertError = new HttpError(assertStatus, 'should not be seen')
|
|
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, assertStatus)
|
|
assert.deepStrictEqual(ctx.body, {
|
|
status: assertStatus,
|
|
message: 'Internal Server Error',
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('_onreqerror', function() {
|
|
t.test('a valid function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.strictEqual(typeof(flaska._onreqerror), 'function')
|
|
})
|
|
|
|
t.test('default valid handling of aborted', function() {
|
|
const assertError = new Error('aborted')
|
|
let flaska = new Flaska({}, faker)
|
|
let ctx = createCtx()
|
|
flaska._onreqerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.info.callCount, 0)
|
|
assert.strictEqual(ctx.log.error.callCount, 0)
|
|
})
|
|
})
|
|
|
|
t.describe('#devMode()', function() {
|
|
t.test('turns on debug mode', function() {
|
|
const assertErrorMessage = 'Fascination'
|
|
const assertError = new Error(assertErrorMessage)
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, 500)
|
|
assert.deepStrictEqual(ctx.body, {
|
|
status: 500,
|
|
message: 'Internal Server Error',
|
|
})
|
|
ctx = createCtx()
|
|
flaska._backuperror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, 500)
|
|
assert.deepStrictEqual(ctx.body, {
|
|
status: 500,
|
|
message: 'Internal Server Error',
|
|
})
|
|
flaska.devMode()
|
|
ctx = createCtx()
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, 500)
|
|
assert.strictEqual(ctx.body.status, 500)
|
|
assert.match(ctx.body.message, /Internal Server Error/)
|
|
assert.match(ctx.body.message, new RegExp(assertErrorMessage))
|
|
assert.ok(ctx.body.stack)
|
|
ctx = createCtx()
|
|
flaska._backuperror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, 500)
|
|
assert.strictEqual(ctx.body.status, 500)
|
|
assert.match(ctx.body.message, /Internal Server Error/)
|
|
assert.match(ctx.body.message, new RegExp(assertErrorMessage))
|
|
assert.ok(ctx.body.stack)
|
|
})
|
|
|
|
t.test('default valid handling of HttpError', function() {
|
|
const assertStatus = 431
|
|
const assertBody = { a: 1 }
|
|
const assertError = new HttpError(assertStatus, 'should not be seen', assertBody)
|
|
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.devMode()
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, assertStatus)
|
|
assert.strictEqual(ctx.body, assertBody)
|
|
})
|
|
|
|
t.test('default valid handling of HttpError with no body', function() {
|
|
const assertStatus = 413
|
|
const assertErrorMessage = 'A day'
|
|
const assertError = new HttpError(assertStatus, assertErrorMessage)
|
|
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.devMode()
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, assertStatus)
|
|
assert.strictEqual(ctx.body.status, assertStatus)
|
|
assert.match(ctx.body.message, /Payload Too Large/)
|
|
assert.match(ctx.body.message, new RegExp(assertErrorMessage))
|
|
})
|
|
|
|
t.test('default valid handling of HttpError with missing status message', function() {
|
|
const assertStatus = 432
|
|
const assertErrorMessage = 'Jet Coaster Ride'
|
|
const assertError = new HttpError(assertStatus, assertErrorMessage)
|
|
|
|
let ctx = createCtx()
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.devMode()
|
|
flaska._onerror(assertError, ctx)
|
|
assert.strictEqual(ctx.log.error.callCount, 1)
|
|
assert.strictEqual(ctx.log.error.firstCall[0], assertError)
|
|
assert.strictEqual(ctx.status, assertStatus)
|
|
assert.strictEqual(ctx.body.status, assertStatus)
|
|
assert.match(ctx.body.message, /Internal Server Error/)
|
|
})
|
|
})
|
|
|
|
t.describe('#before()', function() {
|
|
t.test('should throw if not a function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.throws(function() { flaska.before() }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.before('asdf') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.before('123') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.before([]) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.before({}) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.before(1234) }, /[Ff]unction/)
|
|
})
|
|
|
|
t.test('add handler to preflight list', function() {
|
|
const assertFunction = function() {}
|
|
let flaska = new Flaska({}, faker)
|
|
assert.ok(flaska._before)
|
|
flaska.before(assertFunction)
|
|
assert.strictEqual(flaska._before.length, 2)
|
|
assert.strictEqual(flaska._before[1], assertFunction)
|
|
})
|
|
})
|
|
|
|
t.describe('#beforeAsync()', function() {
|
|
t.test('should throw if not a function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.throws(function() { flaska.beforeAsync() }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.beforeAsync('asdf') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.beforeAsync('123') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.beforeAsync([]) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.beforeAsync({}) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.beforeAsync(1234) }, /[Ff]unction/)
|
|
})
|
|
|
|
t.test('add handler to preflight list', function() {
|
|
const assertFunction = function() {}
|
|
let flaska = new Flaska({}, faker)
|
|
assert.ok(flaska._beforeAsync)
|
|
flaska.beforeAsync(assertFunction)
|
|
assert.strictEqual(flaska._beforeAsync.length, 1)
|
|
assert.strictEqual(flaska._beforeAsync[0], assertFunction)
|
|
})
|
|
})
|
|
|
|
t.describe('#after()', function() {
|
|
t.test('should throw if not a function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.throws(function() { flaska.after() }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.after('asdf') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.after('123') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.after([]) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.after({}) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.after(1234) }, /[Ff]unction/)
|
|
})
|
|
|
|
t.test('add handler to preflight list', function() {
|
|
const assertFunction = function() {}
|
|
let flaska = new Flaska({}, faker)
|
|
assert.ok(flaska._after)
|
|
flaska.after(assertFunction)
|
|
assert.strictEqual(flaska._after.length, 1)
|
|
assert.strictEqual(flaska._after[0], assertFunction)
|
|
})
|
|
})
|
|
|
|
t.describe('#afterAsync()', function() {
|
|
t.test('should throw if not a function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.throws(function() { flaska.afterAsync() }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.afterAsync('asdf') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.afterAsync('123') }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.afterAsync([]) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.afterAsync({}) }, /[Ff]unction/)
|
|
assert.throws(function() { flaska.afterAsync(1234) }, /[Ff]unction/)
|
|
})
|
|
|
|
t.test('add handler to preflight list', function() {
|
|
const assertFunction = function() {}
|
|
let flaska = new Flaska({}, faker)
|
|
assert.ok(flaska._afterAsync)
|
|
flaska.afterAsync(assertFunction)
|
|
assert.strictEqual(flaska._afterAsync.length, 1)
|
|
assert.strictEqual(flaska._afterAsync[0], assertFunction)
|
|
})
|
|
})
|
|
|
|
t.describe('#compile()', function() {
|
|
t.test('join all before together in one function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.before(function(ctx) { ctx.a = 1 })
|
|
flaska.before(function(ctx) { ctx.b = 2 })
|
|
flaska.before(function(ctx) { ctx.c = 3 })
|
|
flaska.before(function(ctx) { ctx.d = 4 })
|
|
assert.notOk(flaska._beforeCompiled)
|
|
flaska.__compile()
|
|
assert.ok(flaska._beforeCompiled)
|
|
assert.notOk(flaska._beforeAsyncCompiled)
|
|
assert.strictEqual(typeof(flaska._beforeCompiled), 'function')
|
|
let ctx = createCtx()
|
|
flaska._beforeCompiled(ctx)
|
|
assert.strictEqual(ctx.a, 1)
|
|
assert.strictEqual(ctx.b, 2)
|
|
assert.strictEqual(ctx.c, 3)
|
|
assert.strictEqual(ctx.d, 4)
|
|
})
|
|
t.test('join all beforeAsync together in one function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.beforeAsync(function(ctx) { return Promise.resolve().then(function() { ctx.a = 1 }) })
|
|
flaska.beforeAsync(function(ctx) { ctx.b = 2 })
|
|
flaska.beforeAsync(function(ctx) { return new Promise(function(res) { ctx.c = 3; res() }) })
|
|
flaska.beforeAsync(function(ctx) { ctx.d = 4 })
|
|
assert.notOk(flaska._beforeAsyncCompiled)
|
|
flaska.__compile()
|
|
assert.ok(flaska._beforeAsyncCompiled)
|
|
assert.strictEqual(typeof(flaska._beforeAsyncCompiled), 'function')
|
|
let ctx = createCtx()
|
|
return flaska._beforeAsyncCompiled(ctx).then(function() {
|
|
assert.strictEqual(ctx.a, 1)
|
|
assert.strictEqual(ctx.b, 2)
|
|
assert.strictEqual(ctx.c, 3)
|
|
assert.strictEqual(ctx.d, 4)
|
|
})
|
|
})
|
|
t.test('join all after together in one function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.after(function(ctx) { ctx.a = 1 })
|
|
flaska.after(function(ctx) { ctx.b = 2 })
|
|
flaska.after(function(ctx) { ctx.c = 3 })
|
|
flaska.after(function(ctx) { ctx.d = 4 })
|
|
assert.notOk(flaska._afterCompiled)
|
|
flaska.__compile()
|
|
assert.ok(flaska._afterCompiled)
|
|
assert.notOk(flaska._afterAsyncCompiled)
|
|
assert.strictEqual(typeof(flaska._afterCompiled), 'function')
|
|
let ctx = createCtx()
|
|
flaska._afterCompiled(ctx)
|
|
assert.strictEqual(ctx.a, 1)
|
|
assert.strictEqual(ctx.b, 2)
|
|
assert.strictEqual(ctx.c, 3)
|
|
assert.strictEqual(ctx.d, 4)
|
|
})
|
|
t.test('join all afterAsync together in one function', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.afterAsync(function(ctx) { return Promise.resolve().then(function() { ctx.a = 1 }) })
|
|
flaska.afterAsync(function(ctx) { ctx.b = 2 })
|
|
flaska.afterAsync(function(ctx) { return new Promise(function(res) { ctx.c = 3; res() }) })
|
|
flaska.afterAsync(function(ctx) { ctx.d = 4 })
|
|
assert.notOk(flaska._afterAsyncCompiled)
|
|
flaska.__compile()
|
|
assert.ok(flaska._afterAsyncCompiled)
|
|
assert.strictEqual(typeof(flaska._afterAsyncCompiled), 'function')
|
|
let ctx = createCtx()
|
|
return flaska._afterAsyncCompiled(ctx).then(function() {
|
|
assert.strictEqual(ctx.a, 1)
|
|
assert.strictEqual(ctx.b, 2)
|
|
assert.strictEqual(ctx.c, 3)
|
|
assert.strictEqual(ctx.d, 4)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('#runHandlers()', function() {
|
|
t.test('should work with empty array', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.__runHandlers({}, [], 0)
|
|
})
|
|
|
|
t.test('should work with correct index', function() {
|
|
let checkIsTrue = false
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.__runHandlers({}, [
|
|
function() { throw new Error('should not be thrown') },
|
|
function() { throw new Error('should not be thrown') },
|
|
function() { throw new Error('should not be thrown') },
|
|
function() { checkIsTrue = true },
|
|
], 3)
|
|
assert.strictEqual(checkIsTrue, true)
|
|
})
|
|
|
|
t.test('should work with static functions', function() {
|
|
const assertCtx = createCtx({ a: 1 })
|
|
let checkCounter = 0
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.__runHandlers(assertCtx, [
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); checkCounter++ },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); checkCounter++ },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); checkCounter++ },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); checkCounter++ },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); checkCounter++ },
|
|
], 0)
|
|
assert.strictEqual(checkCounter, 5)
|
|
})
|
|
|
|
t.test('should work with random promises inbetween', function() {
|
|
const assertCtx = createCtx({ a: 1 })
|
|
let checkCounter = 0
|
|
let flaska = new Flaska({}, faker)
|
|
let result = flaska.__runHandlers(assertCtx, [
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 0); checkCounter++ },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 1); checkCounter++ },
|
|
function(ctx) { return new Promise(function(res) { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 2); checkCounter++; res() }) },
|
|
function(ctx) { return Promise.resolve().then(function() { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 3); checkCounter++ }) },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 4); checkCounter++ },
|
|
function(ctx) { return Promise.resolve().then(function() { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 5); checkCounter++ }) },
|
|
function(ctx) { return Promise.resolve().then(function() { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 6); checkCounter++ }) },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 7); checkCounter++ },
|
|
function(ctx) { assert.strictEqual(ctx, assertCtx); assert.strictEqual(checkCounter, 8); checkCounter++ },
|
|
], 0)
|
|
assert.ok(result)
|
|
assert.strictEqual(typeof(result.then), 'function')
|
|
return result.then(function() {
|
|
assert.strictEqual(checkCounter, 9)
|
|
})
|
|
})
|
|
|
|
t.test('should work with rejected promises inbetween', async function() {
|
|
const assertError = { a: 1 }
|
|
let checkCounter = 0
|
|
let flaska = new Flaska({}, faker)
|
|
let err = await assert.isRejected(flaska.__runHandlers({}, [
|
|
function() { },
|
|
function() { return new Promise(function(res, rej) { rej(assertError) }) },
|
|
function() { throw new Error('should not be seen') },
|
|
], 0))
|
|
assert.strictEqual(err, assertError)
|
|
err = await assert.isRejected(flaska.__runHandlers({}, [
|
|
function() { },
|
|
function() { return Promise.reject(assertError) },
|
|
function() { throw new Error('should not be seen') },
|
|
], 0))
|
|
assert.strictEqual(err, assertError)
|
|
err = await assert.isRejected(flaska.__runHandlers({}, [
|
|
function() { },
|
|
function() { return Promise.resolve() },
|
|
function() { throw assertError },
|
|
], 0))
|
|
assert.strictEqual(err, assertError)
|
|
})
|
|
})
|
|
|
|
t.describe('#listen()', function() {
|
|
t.test('it should throw if missing port', function() {
|
|
let flaska = new Flaska({}, faker)
|
|
assert.throws(function() { flaska.listen() }, /[Pp]ort/)
|
|
assert.throws(function() { flaska.listen('asdf') }, /[Pp]ort/)
|
|
assert.throws(function() { flaska.listen('123') }, /[Pp]ort/)
|
|
assert.throws(function() { flaska.listen([]) }, /[Pp]ort/)
|
|
assert.throws(function() { flaska.listen({}) }, /[Pp]ort/)
|
|
assert.throws(function() { flaska.listen(function() {}) }, /[Pp]ort/)
|
|
})
|
|
|
|
t.test('it should automatically call compile', function() {
|
|
let assertCalled = false
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.__compile = function() { assertCalled = true }
|
|
flaska.listen(404)
|
|
assert.strictEqual(assertCalled, true)
|
|
})
|
|
|
|
t.test('call http correctly', function() {
|
|
const assertPort = 325897235
|
|
const assertIp = 'asdga'
|
|
const assertCb = function() { }
|
|
let checkPort = null
|
|
let checkIp = null
|
|
let checkListenCb = null
|
|
|
|
let testFaker = fakeHttp(null, function(port, ip, cb) {
|
|
checkPort = port
|
|
checkIp = ip
|
|
checkListenCb = cb
|
|
})
|
|
let flaska = new Flaska({}, testFaker)
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
flaska.listen(assertPort, assertIp, assertCb)
|
|
assert.strictEqual(checkPort, assertPort)
|
|
assert.strictEqual(checkIp, assertIp)
|
|
assert.strictEqual(checkListenCb, assertCb)
|
|
})
|
|
|
|
t.test('call http correctly if only port is specified', function() {
|
|
const assertPort = 325897235
|
|
const assertCb = function() { }
|
|
let checkPort = null
|
|
let checkIp = null
|
|
let checkListenCb = null
|
|
|
|
let testFaker = fakeHttp(null, function(port, ip, cb) {
|
|
checkPort = port
|
|
checkIp = ip
|
|
checkListenCb = cb
|
|
})
|
|
let flaska = new Flaska({}, testFaker)
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
flaska.listen(assertPort, assertCb)
|
|
assert.strictEqual(checkPort, assertPort)
|
|
assert.strictEqual(checkIp, '::')
|
|
assert.strictEqual(checkListenCb, assertCb)
|
|
})
|
|
|
|
t.test('register requestStart if no async', function() {
|
|
let checkIsTrue = false
|
|
let checkInternalThis = null
|
|
let checkHandler = null
|
|
|
|
let testFaker = fakeHttp(function(cb) {
|
|
checkHandler = cb
|
|
})
|
|
let flaska = new Flaska({}, testFaker)
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
flaska.listen(404)
|
|
assert.strictEqual(typeof(checkHandler), 'function')
|
|
assert.notStrictEqual(checkHandler, flaska.__requestStart)
|
|
assert.notStrictEqual(checkIsTrue, true)
|
|
assert.notStrictEqual(checkInternalThis, flaska)
|
|
checkHandler()
|
|
assert.strictEqual(checkIsTrue, true)
|
|
assert.strictEqual(checkInternalThis, flaska)
|
|
})
|
|
})
|
|
|
|
t.describe('#listenAsync()', function() {
|
|
t.test('it should throw if missing port', async function() {
|
|
let flaska = new Flaska({}, faker)
|
|
|
|
let tests = [
|
|
undefined,
|
|
'asdf',
|
|
'123',
|
|
[],
|
|
{},
|
|
function() {},
|
|
]
|
|
let errors = await Promise.all(tests.map(x => assert.isRejected(flaska.listenAsync(x))))
|
|
assert.strictEqual(errors.length, tests.length)
|
|
for (let i = 0; i < errors.length; i++) {
|
|
assert.match(errors[i].message, /[Pp]ort/)
|
|
}
|
|
})
|
|
|
|
t.test('it should automatically call compile', async function() {
|
|
let assertCalled = false
|
|
let flaska = new Flaska({}, faker)
|
|
flaska.__compile = function() { assertCalled = true }
|
|
await flaska.listenAsync(404)
|
|
assert.strictEqual(assertCalled, true)
|
|
})
|
|
|
|
t.test('call http correctly', async function() {
|
|
const assertPort = 325897235
|
|
const assertIp = 'asdf'
|
|
let checkPort = null
|
|
let checkIp = null
|
|
|
|
let testFaker = fakeHttp(null, function(port, ip, cb) {
|
|
checkPort = port
|
|
checkIp = ip
|
|
cb()
|
|
})
|
|
|
|
let flaska = new Flaska({}, testFaker)
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
await flaska.listenAsync(assertPort, assertIp)
|
|
assert.strictEqual(checkPort, assertPort)
|
|
assert.strictEqual(checkIp, assertIp)
|
|
})
|
|
|
|
t.test('call http and listen correctly if only port specified', async function() {
|
|
const assertPort = 325897235
|
|
let checkPort = null
|
|
let checkIp = null
|
|
|
|
let testFaker = fakeHttp(null, function(port, ip, cb) {
|
|
checkPort = port
|
|
checkIp = ip
|
|
cb()
|
|
})
|
|
let flaska = new Flaska({}, testFaker)
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
await flaska.listenAsync(assertPort)
|
|
assert.strictEqual(checkPort, assertPort)
|
|
assert.strictEqual(checkIp, '::')
|
|
})
|
|
|
|
t.test('call http and listenAsync correctly if supported', async function() {
|
|
const assertPort = 4632
|
|
const assertIp = 'asdf'
|
|
const assertReturns = { a: 1 }
|
|
const stubListenAsync = stub().resolves(assertReturns)
|
|
|
|
let flaska = new Flaska({}, {
|
|
createServer: function() {
|
|
return {
|
|
listenAsync: stubListenAsync,
|
|
on: stub(),
|
|
}
|
|
}
|
|
})
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
let res = await flaska.listenAsync(assertPort, assertIp)
|
|
assert.strictEqual(res, assertReturns)
|
|
assert.strictEqual(stubListenAsync.firstCall[0], assertPort)
|
|
assert.strictEqual(stubListenAsync.firstCall[1], assertIp)
|
|
})
|
|
|
|
t.test('call http and listenAsync correctly if supported and ip is null', async function() {
|
|
const assertPort = 325897235
|
|
const assertReturns = { a: 1 }
|
|
const stubListenAsync = stub().resolves(assertReturns)
|
|
|
|
let flaska = new Flaska({}, {
|
|
createServer: function() {
|
|
return {
|
|
listenAsync: stubListenAsync,
|
|
on: stub(),
|
|
}
|
|
}
|
|
})
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
let res = await flaska.listenAsync(assertPort)
|
|
assert.strictEqual(res, assertReturns)
|
|
assert.strictEqual(stubListenAsync.firstCall[0], assertPort)
|
|
assert.strictEqual(stubListenAsync.firstCall[1], '::')
|
|
})
|
|
|
|
t.test('register requestStart if no async', async function() {
|
|
let checkIsTrue = false
|
|
let checkInternalThis = null
|
|
let checkHandler = null
|
|
|
|
let testFaker = fakeHttp(function(cb) {
|
|
checkHandler = cb
|
|
})
|
|
let flaska = new Flaska({}, testFaker)
|
|
assert.ok(flaska.__requestStart)
|
|
flaska.__requestStart = function() {
|
|
checkInternalThis = this
|
|
checkIsTrue = true
|
|
}
|
|
await flaska.listenAsync(404)
|
|
assert.strictEqual(typeof(checkHandler), 'function')
|
|
assert.notStrictEqual(checkHandler, flaska.__requestStart)
|
|
assert.notStrictEqual(checkIsTrue, true)
|
|
assert.notStrictEqual(checkInternalThis, flaska)
|
|
checkHandler()
|
|
assert.strictEqual(checkIsTrue, true)
|
|
assert.strictEqual(checkInternalThis, flaska)
|
|
})
|
|
})
|
|
|
|
t.describe('#closeAsync()', function() {
|
|
t.test('it return if server is null', function() {
|
|
let flaska = new Flaska()
|
|
flaska.server = null
|
|
return flaska.closeAsync()
|
|
})
|
|
|
|
t.test('it should call close on server correctly', async function() {
|
|
const assertError = new Error('Pirate Fight')
|
|
let flaska = new Flaska()
|
|
flaska.server = {
|
|
close: stub()
|
|
}
|
|
flaska.server.close.returnWith(function(cb) {
|
|
cb(assertError)
|
|
})
|
|
let err = await assert.isRejected(flaska.closeAsync())
|
|
assert.strictEqual(err, assertError)
|
|
})
|
|
|
|
t.test('it should call closeAllConnections', async function() {
|
|
const assertError = new Error('Pirate Fight')
|
|
let flaska = new Flaska()
|
|
flaska.server = {
|
|
close: stub(),
|
|
closeAllConnections: stub(),
|
|
}
|
|
flaska.server.closeAllConnections.throws(assertError)
|
|
let err = await assert.isRejected(flaska.closeAsync())
|
|
assert.strictEqual(err, assertError)
|
|
})
|
|
|
|
t.test('should otherwise work', async function() {
|
|
let flaska = new Flaska()
|
|
flaska.server = {
|
|
close: stub(),
|
|
closeAllConnections: stub(),
|
|
}
|
|
flaska.server.close.returnWith(function(cb) {
|
|
cb(null, { a: 1 })
|
|
})
|
|
let res = await flaska.closeAsync()
|
|
assert.notOk(res)
|
|
})
|
|
})
|