storage-upload/test/media/routes.test.mjs

699 lines
22 KiB
JavaScript
Raw Normal View History

import fs from 'fs/promises'
import { Eltro as t, assert, stub } from 'eltro'
import { createContext } from '../helper.server.mjs'
import MediaRoutes from '../../api/media/routes.mjs'
import { HttpError } from '../../api/error.mjs'
t.before(function() {
return Promise.all([
fs.readdir('./public/development').then(files => {
return Promise.all(files.map(function(file) {
if (file !== '.gitkeep') {
return fs.unlink(`./public/development/${file}`).catch(function() {})
}
return Promise.resolve()
}))
}),
])
})
t.describe('#filesCacheGet', function() {
t.test('should return all files in public folder', async function() {
const routes = new MediaRoutes()
await routes.init()
assert.ok(routes.filesCacheGet('development'))
assert.ok(Array.isArray(routes.filesCacheGet('development')))
assert.ok(routes.filesCacheGet('existing'))
assert.ok(Array.isArray(routes.filesCacheGet('existing')))
assert.ok(routes.filesCacheGet('nonexisting'))
assert.ok(Array.isArray(routes.filesCacheGet('nonexisting')))
assert.strictEqual(routes.filesCacheGet('development').length, 1)
assert.strictEqual(routes.filesCacheGet('existing').length, 2)
assert.strictEqual(routes.filesCacheGet('nonexisting').length, 0)
assert.strictEqual(routes.filesCacheGet('development')[0].filename, '.gitkeep')
assert.strictEqual(routes.filesCacheGet('development')[0].size, 0)
assert.strictEqual(routes.filesCacheGet('existing')[0].filename, '20220105_101610_test1.jpg')
assert.strictEqual(routes.filesCacheGet('existing')[0].size, 15079)
assert.strictEqual(routes.filesCacheGet('existing')[1].filename, '20220105_101610_test2.png')
assert.strictEqual(routes.filesCacheGet('existing')[1].size, 31705)
})
t.test('should always sort result', async function() {
const routes = new MediaRoutes()
await routes.init()
let files = routes.filesCacheGet('existing')
assert.strictEqual(files[0].filename, '20220105_101610_test1.jpg')
assert.strictEqual(files[0].size, 15079)
assert.strictEqual(files[1].filename, '20220105_101610_test2.png')
assert.strictEqual(files[1].size, 31705)
routes.siteCache.get('existing').push({ filename: '0000.png', size: 0 })
files = routes.filesCacheGet('existing')
assert.strictEqual(files[0].filename, '0000.png')
assert.strictEqual(files[0].size, 0)
assert.strictEqual(files[1].filename, '20220105_101610_test1.jpg')
assert.strictEqual(files[1].size, 15079)
assert.strictEqual(files[2].filename, '20220105_101610_test2.png')
assert.strictEqual(files[2].size, 31705)
})
})
t.describe('#listFiles()', function() {
const stubVerify = stub()
const stubGetCache = stub()
const routes = new MediaRoutes({
security: { verifyToken: stubVerify },
})
routes.filesCacheGet = stubGetCache
function reset() {
stubVerify.reset()
stubGetCache.reset()
}
t.test('should call security correctly', async function() {
reset()
let ctx = createContext()
const assertError = new Error('temp')
stubVerify.rejects(assertError)
let err = await assert.isRejected(routes.listFiles(ctx))
assert.ok(stubVerify.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubVerify.firstCall[0], ctx)
})
t.test('should call filesCacheGet and return results', async function() {
reset()
let ctx = createContext()
const assertSiteName = 'benshapiro'
const assertResult = { a: 1 }
stubVerify.resolves(assertSiteName)
stubGetCache.returns(assertResult)
await routes.listFiles(ctx)
assert.ok(stubGetCache.called)
assert.strictEqual(stubGetCache.firstCall[0], assertSiteName)
assert.strictEqual(ctx.body, assertResult)
})
})
t.describe('#listPublicFiles()', function() {
const stubSitePublic = stub()
const stubGetCache = stub()
const routes = new MediaRoutes({
security: { throwIfNotPublic: stubSitePublic },
})
routes.filesCacheGet = stubGetCache
function reset() {
stubSitePublic.reset()
stubGetCache.reset()
}
t.test('should call security correctly', async function() {
reset()
let ctx = createContext()
const assertError = new Error('temp')
const assertSite = 'astalavista'
stubSitePublic.throws(assertError)
ctx.params.site = assertSite
let err = await assert.isRejected(routes.listPublicFiles(ctx))
assert.ok(stubSitePublic.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubSitePublic.firstCall[0], assertSite)
})
t.test('should call filesCacheGet and return results', async function() {
reset()
let ctx = createContext()
const assertSiteName = 'benshapiro'
const assertResult = { a: 1 }
ctx.params.site = assertSiteName
stubGetCache.returns(assertResult)
await routes.listPublicFiles(ctx)
assert.ok(stubGetCache.called)
assert.strictEqual(stubGetCache.firstCall[0], assertSiteName)
assert.strictEqual(ctx.body, assertResult)
})
})
t.describe('#filesCacheAdd', function() {
t.test('should auto-create array of site and add file', async function() {
const routes = new MediaRoutes()
const assertName = 'asdf.png'
const assertSize = 1234
await routes.init()
assert.ok(routes.filesCacheGet('nonexisting'))
assert.ok(Array.isArray(routes.filesCacheGet('nonexisting')))
assert.strictEqual(routes.filesCacheGet('nonexisting').length, 0)
routes.filesCacheAdd('nonexisting', assertName, assertSize)
assert.strictEqual(routes.filesCacheGet('nonexisting').length, 1)
assert.strictEqual(routes.filesCacheGet('nonexisting')[0].filename, assertName)
assert.strictEqual(routes.filesCacheGet('nonexisting')[0].size, assertSize)
})
t.test('should not add but update size if file already exists', function() {
const routes = new MediaRoutes()
const assertName = 'asdf.png'
const assertSize = 1234
const assertNewSize = 5678
assert.ok(routes.filesCacheGet('nonexisting'))
assert.ok(Array.isArray(routes.filesCacheGet('nonexisting')))
assert.strictEqual(routes.filesCacheGet('nonexisting').length, 0)
routes.filesCacheAdd('nonexisting', assertName, assertSize)
assert.strictEqual(routes.filesCacheGet('nonexisting').length, 1)
assert.strictEqual(routes.filesCacheGet('nonexisting')[0].filename, assertName)
assert.strictEqual(routes.filesCacheGet('nonexisting')[0].size, assertSize)
routes.filesCacheAdd('nonexisting', assertName, assertNewSize)
assert.strictEqual(routes.filesCacheGet('nonexisting').length, 1)
assert.strictEqual(routes.filesCacheGet('nonexisting')[0].filename, assertName)
assert.strictEqual(routes.filesCacheGet('nonexisting')[0].size, assertNewSize)
})
})
t.describe('#filesCacheRemove', function() {
t.test('should default not do anything if nothing is found', async function() {
const routes = new MediaRoutes()
await routes.init()
assert.ok(routes.filesCacheGet('existing'))
assert.ok(Array.isArray(routes.filesCacheGet('existing')))
assert.strictEqual(routes.filesCacheGet('existing').length, 2)
routes.filesCacheRemove('nonexisting', 'bla.text')
routes.filesCacheRemove('nonexisting', 'herp.derp')
routes.filesCacheRemove('existing', 'bla.text')
routes.filesCacheRemove('existing', 'herp.derp')
assert.ok(routes.filesCacheGet('existing'))
assert.ok(Array.isArray(routes.filesCacheGet('existing')))
assert.strictEqual(routes.filesCacheGet('existing').length, 2)
})
t.test('should otherwise remove entries that match filename', async function() {
const routes = new MediaRoutes()
await routes.init()
assert.ok(routes.filesCacheGet('existing'))
assert.ok(Array.isArray(routes.filesCacheGet('existing')))
assert.strictEqual(routes.filesCacheGet('existing').length, 2)
routes.filesCacheRemove('existing', '20220105_101610_test1.jpg')
assert.ok(routes.filesCacheGet('existing'))
assert.ok(Array.isArray(routes.filesCacheGet('existing')))
assert.strictEqual(routes.filesCacheGet('existing').length, 1)
assert.strictEqual(routes.filesCacheGet('existing')[0].filename, '20220105_101610_test2.png')
})
})
t.describe('#uploadNoPrefix', function() {
const stubVerify = stub()
const stubUpload = stub()
const stubStat = stub()
const routes = new MediaRoutes({
security: {
verifyToken: stubVerify,
verifyBody: stub(),
},
formidable: { uploadFile: stubUpload, },
fs: { stat: stubStat },
})
function reset() {
stubVerify.reset()
stubUpload.reset()
stubStat.reset()
}
t.test('should call upload correctly', async function() {
reset()
let ctx = createContext()
const assertSiteName = 'benshapiro'
const assertError = new Error('hello')
stubVerify.resolves(assertSiteName)
stubUpload.rejects(assertError)
let err = await assert.isRejected(routes.uploadNoPrefix(ctx))
assert.ok(stubUpload.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubUpload.firstCall[0], ctx)
assert.strictEqual(stubUpload.firstCall[1], assertSiteName)
assert.strictEqual(stubUpload.firstCall[2], true)
})
})
t.describe('#resize', function() {
const stubVerifyToken = stub()
const stubVerifyBody = stub()
const stubUpload = stub()
const stubSharp = stub()
const stubSharpResize = stub()
const stubSharpBlur = stub()
const stubSharpTrim = stub()
const stubSharpExtend = stub()
const stubSharpFlatten = stub()
const stubSharpRotate = stub()
const stubSharpToFile = stub()
const stubSharpJpeg = stub()
const stubSharpPng = stub()
const stubSharpToBuffer = stub()
const stubStat = stub()
const routes = new MediaRoutes({
security: {
verifyToken: stubVerifyToken,
verifyBody: stubVerifyBody,
},
fs: { stat: stubStat },
formidable: { uploadFile: stubUpload },
sharp: stubSharp,
})
function reset() {
stubVerifyToken.reset()
stubVerifyBody.reset()
stubUpload.reset()
let def = {
toFile: stubSharpToFile,
jpeg: stubSharpJpeg,
png: stubSharpPng,
resize: stubSharpResize,
trim: stubSharpTrim,
extend: stubSharpExtend,
flatten: stubSharpFlatten,
blur: stubSharpBlur,
rotate: stubSharpRotate,
toBuffer: stubSharpToBuffer,
}
stubStat.reset()
stubStat.resolves({ size: 0 })
stubSharp.reset()
stubSharp.returns(def)
for (let key in def) {
def[key].reset()
def[key].returns(def)
}
stubSharpToFile.resolves()
stubSharpToBuffer.resolves()
routes.siteCache.clear()
}
t.test('should call security verifyBody correctly', async function() {
reset()
let ctx = createContext({ req: { body: { }}})
const assertError = new Error('temp')
stubUpload.resolves({ filename: 'bla' })
stubVerifyBody.throws(assertError)
let err = await assert.isRejected(routes.resize(ctx))
assert.strictEqual(err, assertError)
assert.ok(stubVerifyBody.called)
assert.strictEqual(stubVerifyBody.firstCall[0], ctx)
})
t.test('should call sharp correctly if items are specified', async function() {
reset()
const assertKey = 'asdf'
const assertJpeg = { a: 1 }
const assertFilename = 'asdfsafd'
const assertSite = 'mario'
stubVerifyToken.resolves(assertSite)
stubUpload.resolves({ filename: assertFilename + '.png' })
let ctx = createContext({ req: { body: {
[assertKey]: {
format: 'jpeg',
}
}}})
ctx.req.body[assertKey].jpeg = assertJpeg
await routes.resize(ctx)
assert.ok(stubSharp.called)
assert.match(stubSharp.firstCall[0], new RegExp(`\/${assertSite}\/${assertFilename}\.png`))
assert.ok(stubSharpRotate.called)
assert.ok(stubSharpJpeg.called)
assert.strictEqual(stubSharpJpeg.firstCall[0], assertJpeg)
assert.ok(stubSharpToFile.called)
assert.match(stubSharpToFile.firstCall[0], new RegExp(`\/${assertSite}\/${assertFilename}_${assertKey}\.jpg`))
assert.notOk(stubSharpPng.called)
assert.notOk(stubSharpResize.called)
assert.strictEqual(ctx.body.filename, assertFilename + '.png')
assert.strictEqual(ctx.body.path, `/${assertSite}/${assertFilename}.png`)
assert.strictEqual(ctx.body[assertKey].filename, `${assertFilename}_${assertKey}\.jpg`)
assert.strictEqual(ctx.body[assertKey].path, `/${assertSite}/${assertFilename}_${assertKey}.jpg`)
})
let validOperations = [
'resize',
'blur',
'trim',
'extend',
'flatten',
]
let operationStubMap = {
resize: stubSharpResize,
blur: stubSharpBlur,
trim: stubSharpTrim,
extend: stubSharpExtend,
flatten: stubSharpFlatten,
}
validOperations.forEach(function(operation) {
t.test(`should call sharp correctly if items and ${operation} are specified`, async function() {
reset()
const assertKey = 'herpderp'
const assertPng = { a: 1 }
const assertPayload = { a: 1 }
const assertFilename = 'asdfsafd'
const assertSite = 'mario'
stubVerifyToken.resolves(assertSite)
stubUpload.resolves({ filename: assertFilename + '.png' })
let called = 0
stubStat.returnWith(function() {
called += 10
return { size: called }
})
let ctx = createContext({ req: { body: {
[assertKey]: {
format: 'png',
}
}}})
ctx.req.body[assertKey].png = assertPng
ctx.req.body[assertKey][operation] = assertPayload
await routes.resize(ctx)
assert.ok(stubSharp.called)
assert.match(stubSharp.firstCall[0], new RegExp(`\/${assertSite}\/${assertFilename}\.png`))
assert.ok(stubSharpRotate.called)
assert.ok(stubSharpPng.called)
assert.strictEqual(stubSharpPng.firstCall[0], assertPng)
assert.ok(stubSharpToFile.called)
assert.match(stubSharpToFile.firstCall[0], new RegExp(`\/${assertSite}\/${assertFilename}_${assertKey}\.png`))
assert.notOk(stubSharpJpeg.called)
assert.ok(operationStubMap[operation].called)
assert.strictEqual(operationStubMap[operation].firstCall[0], assertPayload)
assert.strictEqual(ctx.body.filename, assertFilename + '.png')
assert.strictEqual(ctx.body.path, `/${assertSite}/${assertFilename}.png`)
assert.strictEqual(ctx.body[assertKey].filename, `${assertFilename}_${assertKey}\.png`)
assert.strictEqual(ctx.body[assertKey].path, `/${assertSite}/${assertFilename}_${assertKey}.png`)
let filesFromCache = routes.filesCacheGet(assertSite)
assert.strictEqual(filesFromCache.length, 2)
assert.strictEqual(filesFromCache[0].filename, `${assertFilename}_${assertKey}\.png`)
assert.strictEqual(filesFromCache[0].size, 20)
assert.strictEqual(filesFromCache[1].filename, assertFilename + '.png')
assert.strictEqual(filesFromCache[1].size, 10)
})
})
t.test('should notify which item failed if one fails', async function() {
reset()
const assertValidKey1 = 'herp'
const assertValidKey2 = 'derp'
const assertErrorKey = 'throwmyerr'
const assertErrorMessage = 'some message here'
stubVerifyToken.resolves('asdf')
stubUpload.resolves({ filename: 'file.png' })
let called = 0
stubStat.returnWith(function() {
called += 10
return { size: called }
})
let ctx = createContext({ req: { body: {
[assertValidKey1]: {
format: 'png',
png: { a: 1 },
},
[assertValidKey2]: {
format: 'png',
png: { a: 1 },
},
[assertErrorKey]: {
format: 'png',
png: { a: 1 },
},
}}})
stubSharpToFile.returnWith(function(file) {
if (file.match(new RegExp(assertErrorKey))) {
throw new Error(assertErrorMessage)
}
})
let err = await assert.isRejected(routes.resize(ctx))
assert.ok(err instanceof HttpError)
assert.ok(err instanceof Error)
assert.strictEqual(err.status, 422)
assert.match(err.message, new RegExp(assertErrorKey))
assert.match(err.message, new RegExp(assertErrorMessage))
})
t.test('should call sharp correctly and return base64 format if out is base64', async function() {
reset()
const assertKey = 'outtest'
const assertFilename = 'asdfsafd.png'
const assertSite = 'mario'
const assertBase64Data = 'asdf1234'
stubVerifyToken.resolves(assertSite)
stubUpload.resolves({ filename: assertFilename })
let ctx = createContext({ req: { body: {
[assertKey]: {
format: 'png',
png: { a: 1 },
out: 'base64',
}
}}})
stubSharpToBuffer.resolves(Buffer.from(assertBase64Data))
await routes.resize(ctx)
assert.ok(stubSharp.called)
assert.notOk(stubSharpToFile.called)
assert.ok(stubSharpToBuffer.called)
assert.ok(ctx.body[assertKey].base64)
assert.ok(ctx.body[assertKey].base64.startsWith(`data:image/png;base64,`))
let base64 = ctx.body[assertKey].base64
let bufferBase64 = Buffer.from(base64.slice(base64.indexOf(',')), 'base64')
assert.strictEqual(bufferBase64.toString(), assertBase64Data)
let filesFromCache = routes.filesCacheGet(assertSite)
assert.strictEqual(filesFromCache.length, 1)
assert.strictEqual(filesFromCache[0].filename, assertFilename)
})
})
let basicUploadTestRoutes = [
'upload',
'resize',
'uploadNoPrefix'
]
basicUploadTestRoutes.forEach(function(name) {
t.describe(`#${name}() Base`, function() {
const stubVerify = stub()
const stubUpload = stub()
const stubStat = stub()
const routes = new MediaRoutes({
security: {
verifyToken: stubVerify,
verifyBody: stub(),
},
formidable: { uploadFile: stubUpload, },
fs: { stat: stubStat },
})
function reset() {
stubVerify.reset()
stubUpload.reset()
stubStat.reset()
}
t.test('should call security correctly', async function() {
reset()
let ctx = createContext({ req: { body: { } } })
const assertError = new Error('temp')
stubVerify.rejects(assertError)
let err = await assert.isRejected(routes[name](ctx))
assert.ok(stubVerify.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubVerify.firstCall[0], ctx)
})
t.test('should call upload correctly', async function() {
reset()
let ctx = createContext({ req: { body: { } } })
const assertSiteName = 'benshapiro'
const assertError = new Error('hello')
stubVerify.resolves(assertSiteName)
stubUpload.rejects(assertError)
let err = await assert.isRejected(routes[name](ctx))
assert.ok(stubUpload.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubUpload.firstCall[0], ctx)
assert.strictEqual(stubUpload.firstCall[1], assertSiteName)
})
t.test('should otherwise return the file in result', async function() {
reset()
let ctx = createContext({ req: { body: { } } })
const assertSize = 1241412
const assertFilename = 'asdfsafd'
const assertSite = 'mario'
stubVerify.resolves(assertSite)
stubUpload.resolves({ filename: assertFilename })
stubStat.resolves({ size: assertSize })
await routes[name](ctx)
assert.strictEqual(ctx.body.filename, assertFilename)
assert.strictEqual(ctx.body.path, `/${assertSite}/${assertFilename}`)
assert.ok(stubStat.called)
assert.strictEqual(stubStat.firstCall[0], `./public/${assertSite}/${assertFilename}`)
let filesFromCache = routes.filesCacheGet(assertSite)
assert.strictEqual(filesFromCache.length, 1)
assert.strictEqual(filesFromCache[0].filename, assertFilename)
assert.strictEqual(filesFromCache[0].size, assertSize)
})
})
})
t.describe('#remove()', function() {
const stubVerify = stub()
const stubUnlink = stub()
const stubCacheRemove = stub()
const routes = new MediaRoutes({
security: {
verifyToken: stubVerify,
},
fs: { unlink: stubUnlink },
})
routes.filesCacheRemove = stubCacheRemove
function reset() {
stubVerify.reset()
stubUnlink.reset()
stubCacheRemove.reset()
stubUnlink.resolves(null)
}
t.test('should call security correctly', async function() {
reset()
let ctx = createContext({ req: { body: { } } })
const assertError = new Error('temp')
stubVerify.rejects(assertError)
let err = await assert.isRejected(routes.remove(ctx))
assert.ok(stubVerify.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubVerify.firstCall[0], ctx)
})
t.test('should call unlink correctly', async function() {
const assertSiteName = 'benshapiro'
const assertFilename = 'somefilename.png'
const assertErrorMessage = 'Noriyasu Agematsu Tensei'
const assertError = new Error(assertErrorMessage)
reset()
let ctx = createContext({ req: { body: { } } })
ctx.params.filename = assertFilename
stubVerify.resolves(assertSiteName)
stubUnlink.rejects(assertError)
let err = await assert.isRejected(routes.remove(ctx))
assert.ok(stubUnlink.called)
assert.ok(err instanceof HttpError)
assert.ok(err instanceof Error)
assert.strictEqual(err.status, 422)
assert.match(err.message, new RegExp(assertSiteName))
assert.match(err.message, new RegExp(assertFilename))
assert.match(err.message, new RegExp(assertErrorMessage))
assert.strictEqual(stubUnlink.firstCall[0], `./public/${assertSiteName}/${assertFilename}`)
})
t.test('should otherwise return 204 status and remove from array', async function() {
const assertSiteName = 'benshapiro'
const assertFilename = 'somefilename.png'
reset()
let ctx = createContext({ req: { body: { } } })
ctx.params.filename = assertFilename
stubVerify.resolves(assertSiteName)
await routes.remove(ctx)
assert.strictEqual(ctx.status, 204)
assert.ok(stubCacheRemove.called)
assert.strictEqual(stubCacheRemove.firstCall[0], assertSiteName)
assert.strictEqual(stubCacheRemove.firstCall[1], assertFilename)
})
})