test: cover error page rendering, cleanup guards and dev listen options

Author: danielroe

packages/nuxt-cli/src/commands/dev.ts

@@ -411,7 +411,7 @@ function resolveForkPoolSize(): number | undefined {
 returnparsed
 }
 
-functionparsePositiveInteger(value: string|undefined): number|undefined{
+exportfunctionparsePositiveInteger(value: string|undefined): number|undefined{
 constparsed=Number(value)
 if(!value||!Number.isInteger(parsed)||parsed<=0){
 if(value){
@@ -422,7 +422,7 @@ function parsePositiveInteger(value: string | undefined): number | undefined {
 returnparsed
 }
 
-functionresolveListenOverrides(args: ParsedArgs<ArgsT>): DevListenOverrides{
+exportfunctionresolveListenOverrides(args: ParsedArgs<ArgsT>): DevListenOverrides{
 consthttpsOptions: HTTPSOptions={
 cert: args['https.cert']
 ||args.sslCert

packages/nuxt-cli/test/unit/commands/dev-args.spec.ts

@@ -0,0 +1,78 @@
+import{afterEach,describe,expect,it,vi}from'vitest'
+
+import{parsePositiveInteger,resolveListenOverrides}from'../../../src/commands/dev'
+
+functionoverrides(args: Record<string,unknown>={}){
+returnresolveListenOverrides({_: [], ...args}asnever)
+}
+
+afterEach(()=>{
+vi.unstubAllEnvs()
+})
+
+describe('resolveListenOverrides',()=>{
+it('should leave the hostname unset when no host is requested',()=>{
+expect(overrides().hostname).toBeUndefined()
+})
+
+it('should treat a bare --host as every interface',()=>{
+expect(overrides({host: true}).hostname).toBe('')
+expect(overrides({host: ''}).hostname).toBe('')
+})
+
+it('should keep an explicit host',()=>{
+expect(overrides({host: '127.0.0.1'}).hostname).toBe('127.0.0.1')
+})
+
+it('should prefer an explicit host over the environment',()=>{
+vi.stubEnv('NUXT_HOST','0.0.0.0')
+expect(overrides({host: '127.0.0.1'}).hostname).toBe('127.0.0.1')
+})
+
+it('should read the host from the environment in precedence order',()=>{
+vi.stubEnv('HOST','from-host')
+expect(overrides().hostname).toBe('from-host')
+vi.stubEnv('NITRO_HOST','from-nitro')
+expect(overrides().hostname).toBe('from-nitro')
+vi.stubEnv('NUXT_HOST','from-nuxt')
+expect(overrides().hostname).toBe('from-nuxt')
+})
+
+it('should read the port from the environment in precedence order',()=>{
+vi.stubEnv('PORT','4000')
+expect(overrides().port).toBe('4000')
+vi.stubEnv('NUXT_PORT','5000')
+expect(overrides().port).toBe('5000')
+expect(overrides({port: '6000'}).port).toBe('6000')
+})
+
+it('should open the browser when only --open.url is given',()=>{
+expect(overrides({'open.url': '/admin'})).toMatchObject({open: true,openURL: '/admin'})
+expect(overrides().open).toBeFalsy()
+})
+
+it('should split https domains and drop empty entries',()=>{
+expect(overrides({'https.domains': 'a.test, b.test ,'}).https).toMatchObject({domains: ['a.test','b.test']})
+})
+
+it('should leave https domains unset when the flag is absent',()=>{
+expect((overrides().httpsas{domains?: string[]}).domains).toBeUndefined()
+})
+
+it('should fall back to the deprecated ssl flags and env vars',()=>{
+vi.stubEnv('NITRO_SSL_KEY','/env/key.pem')
+expect(overrides({sslCert: '/cert.pem'}).https).toMatchObject({cert: '/cert.pem',key: '/env/key.pem'})
+})
+})
+
+describe('parsePositiveInteger',()=>{
+it('should accept a positive integer',()=>{
+expect(parsePositiveInteger('30')).toBe(30)
+})
+
+it('should reject anything else',()=>{
+for(constvalueof[undefined,'','0','-1','1.5','abc']){
+expect(parsePositiveInteger(value),String(value)).toBeUndefined()
+}
+})
+})

packages/nuxt-cli/test/unit/dev/responses.spec.ts

@@ -0,0 +1,139 @@
+importtype{IncomingMessage,ServerResponse}from'node:http'
+
+import{describe,expect,it}from'vitest'
+
+import{renderError}from'../../../src/dev/error'
+import{NuxtDevServer}from'../../../src/dev/utils'
+
+interfaceFakeResponseextendsServerResponse{
+body: string
+statusCode: number
+headers: Record<string,string>
+finished: Promise<void>
+}
+
+functioncreateRequest(accept?: string,url='/'): IncomingMessage{
+return{ url,method: 'GET',headers: accept ? { accept } : {}}asunknownasIncomingMessage
+}
+
+functioncreateResponse(): FakeResponse{
+constheaders: Record<string,string>={}
+letdone: ()=>void
+constfinished=newPromise<void>((resolve)=>{
+done=resolve
+})
+constres={
+statusCode: 200,
+headersSent: false,
+writableEnded: false,
+body: '',
+ headers,
+ finished,
+setHeader(name: string,value: string){
+headers[name.toLowerCase()]=value
+},
+once(){},
+end(chunk?: string){
+if(chunk){
+res.body+=chunk
+}
+res.writableEnded=true
+res.headersSent=true
+done()
+},
+}
+returnresasunknownasFakeResponse
+}
+
+describe('renderError',()=>{
+it('should escape an error message in the html error page',async()=>{
+constres=createResponse()
+awaitrenderError(createRequest('text/html'),res,newError('<script>alert(1)</script>'))
+
+expect(res.statusCode).toBe(500)
+expect(res.headers['content-type']).toBe('text/html')
+expect(res.body).not.toContain('<script>alert(1)</script>')
+expect(res.body).toContain('&lt;script&gt;alert(1)&lt;/script&gt;')
+})
+
+it('should escape a reflected request url in the html error page',async()=>{
+constres=createResponse()
+awaitrenderError(createRequest('text/html','/</script><script>alert(1)</script>'),res,newError('boom'))
+
+expect(res.body).not.toContain('<script>alert(1)</script>')
+})
+
+it('should answer a non-html client with json',async()=>{
+constres=createResponse()
+awaitrenderError(createRequest('application/json'),res,newError('boom'))
+
+expect(res.headers['content-type']).toBe('application/json')
+expect(JSON.parse(res.body)).toMatchObject({error: true,status: 500,message: 'boom'})
+})
+
+it('should send hardening headers with the error page',async()=>{
+constres=createResponse()
+awaitrenderError(createRequest('text/html'),res,newError('boom'))
+
+expect(res.headers).toMatchObject({
+'cache-control': 'no-store',
+'x-content-type-options': 'nosniff',
+'x-frame-options': 'DENY',
+'referrer-policy': 'no-referrer',
+})
+})
+
+it('should not write a body once headers have been sent',async()=>{
+constres=createResponse()
+res.headersSent=true
+awaitrenderError(createRequest('text/html'),res,newError('boom'))
+
+expect(res.body).toBe('')
+})
+
+it('should render a non-error rejection value',async()=>{
+constres=createResponse()
+awaitrenderError(createRequest('application/json'),res,'just a string')
+
+expect(JSON.parse(res.body)).toMatchObject({status: 500,message: 'Unknown error'})
+})
+})
+
+describe('dev server loading screen',()=>{
+functioncreateDevServer(loadingTemplate?: (data: {loading?: string})=>string){
+returnnewNuxtDevServer({cwd: process.cwd(),dotenv: {},overrides: {}, loadingTemplate })
+}
+
+it('should serve the loading template to a browser',async()=>{
+constserver=createDevServer(({ loading })=>`<p>${loading}</p>`)
+constres=createResponse()
+
+server.handler(createRequest('text/html'),res)
+awaitres.finished
+
+expect(res.statusCode).toBe(503)
+expect(res.headers['content-type']).toBe('text/html')
+expect(res.body).toBe('<p>Loading...</p>')
+})
+
+it('should serve json to a non-browser client',async()=>{
+constserver=createDevServer(()=>'<p>ignored</p>')
+constres=createResponse()
+
+server.handler(createRequest('application/json'),res)
+awaitres.finished
+
+expect(res.statusCode).toBe(503)
+expect(JSON.parse(res.body)).toMatchObject({error: true,status: 503})
+})
+
+it('should ask clients to retry rather than caching the placeholder',async()=>{
+constserver=createDevServer(()=>'loading')
+constres=createResponse()
+
+server.handler(createRequest('text/html'),res)
+awaitres.finished
+
+expect(res.headers).toMatchObject({'cache-control': 'no-store','refresh': '3'})
+})
+})

packages/nuxt-cli/test/unit/utils/nuxt.spec.ts

@@ -0,0 +1,63 @@
+import{existsSync}from'node:fs'
+import{mkdir,mkdtemp,rm,writeFile}from'node:fs/promises'
+import{tmpdir}from'node:os'
+import{join}from'node:path'
+
+import{afterEach,beforeEach,describe,expect,it}from'vitest'
+
+import{cleanupNuxtDirs,nuxtVersionToGitIdentifier}from'../../../src/utils/nuxt'
+
+letroot: string
+
+beforeEach(async()=>{
+root=awaitmkdtemp(join(tmpdir(),'nuxt-cleanup-'))
+})
+
+afterEach(async()=>{
+awaitrm(root,{recursive: true,force: true})
+})
+
+asyncfunctionseed(...dirs: string[]): Promise<void>{
+for(constdirofdirs){
+awaitmkdir(join(root,dir),{recursive: true})
+awaitwriteFile(join(root,dir,'file.txt'),'x')
+}
+}
+
+describe('cleanupNuxtDirs',()=>{
+it('should remove the generated directories',async()=>{
+awaitseed('.nuxt','.output','dist','node_modules/.vite','node_modules/.cache','app')
+
+awaitcleanupNuxtDirs(root,'.nuxt',{silent: true})
+
+for(constdirof['.nuxt','.output','dist','node_modules/.vite','node_modules/.cache']){
+expect(existsSync(join(root,dir)),dir).toBe(false)
+}
+expect(existsSync(join(root,'app'))).toBe(true)
+})
+
+it('should refuse a build directory that is the project root',async()=>{
+awaitseed('app')
+
+awaitexpect(cleanupNuxtDirs(root,'.',{silent: true})).rejects.toThrow('contains the project root')
+expect(existsSync(join(root,'app'))).toBe(true)
+})
+
+it('should refuse a build directory that contains the project root',async()=>{
+awaitseed('app')
+
+awaitexpect(cleanupNuxtDirs(root,'..',{silent: true})).rejects.toThrow('contains the project root')
+expect(existsSync(join(root,'app'))).toBe(true)
+})
+})
+
+describe('nuxtVersionToGitIdentifier',()=>{
+it('should use the git identifier of a nightly version',()=>{
+expect(nuxtVersionToGitIdentifier('3.0.0-rc.8-27677607.a3a8706')).toBe('a3a8706')
+})
+
+it('should fall back to the release tag',()=>{
+expect(nuxtVersionToGitIdentifier('3.0.0-rc.8')).toBe('v3.0.0-rc.8')
+expect(nuxtVersionToGitIdentifier('4.1.0')).toBe('v4.1.0')
+})
+})