test: cover dev initialize wiring, close ordering and profiling

Author: danielroe

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

@@ -0,0 +1,145 @@
+import{EventEmitter}from'node:events'
+importprocessfrom'node:process'
+
+import{afterEach,beforeEach,describe,expect,it,vi}from'vitest'
+
+const{ closeListener, closeNuxt, closeWatchers, devServers, releaseLock, startCpuProfile, stopCpuProfile }=vi.hoisted(()=>({
+closeListener: vi.fn(()=>Promise.resolve()),
+closeNuxt: vi.fn(()=>Promise.resolve()),
+closeWatchers: vi.fn(),
+devServers: []asany[],
+releaseLock: vi.fn(),
+startCpuProfile: vi.fn(()=>Promise.resolve()),
+stopCpuProfile: vi.fn(),
+}))
+
+vi.mock('../../../src/utils/profile.ts',()=>({ startCpuProfile, stopCpuProfile }))
+vi.mock('../../../src/utils/env.ts',()=>({overrideEnv: vi.fn()}))
+
+vi.mock('../../../src/dev/utils',()=>({
+NuxtDevServer: classextendsEventEmitter{
+listener={url: 'http://127.0.0.1:3000',close: closeListener}
+closeWatchers=closeWatchers
+close=closeNuxt
+releaseLock=releaseLock
+load=vi.fn(()=>Promise.resolve())
+
+constructor(readonlyoptions: Record<string,any>){
+super()
+devServers.push(this)
+}
+
+init=vi.fn(async()=>{
+this.emit('ready','http://127.0.0.1:3000')
+})
+},
+}))
+
+const{ initialize }=awaitimport('../../../src/dev/index')
+
+functioncontext(args: Record<string,unknown>={}){
+return{cwd: process.cwd(),args: { ...args}}asnever
+}
+
+beforeEach(()=>{
+devServers.length=0
+vi.clearAllMocks()
+})
+
+afterEach(()=>{
+vi.restoreAllMocks()
+})
+
+describe('initialize',()=>{
+it('should report the address to a callback registered after ready',async()=>{
+const{ onReady }=awaitinitialize(context())
+constseen: string[]=[]
+
+onReady(address=>seen.push(address))
+
+expect(seen).toEqual(['http://127.0.0.1:3000'])
+})
+
+it('should close the watchers, the listener and nuxt before releasing the lock',async()=>{
+constorder: string[]=[]
+closeWatchers.mockImplementation(()=>order.push('watchers'))
+closeListener.mockImplementation(async()=>voidorder.push('listener'))
+closeNuxt.mockImplementation(async()=>voidorder.push('nuxt'))
+releaseLock.mockImplementation(()=>order.push('lock'))
+
+const{ close }=awaitinitialize(context())
+awaitclose()
+
+expect(order[0]).toBe('watchers')
+expect(order.at(-1)).toBe('lock')
+expect(order).toContain('listener')
+expect(order).toContain('nuxt')
+})
+
+it('should close only once however often it is asked',async()=>{
+const{ close }=awaitinitialize(context())
+
+awaitPromise.all([close(),close()])
+awaitclose()
+
+expect(releaseLock).toHaveBeenCalledTimes(1)
+expect(closeListener).toHaveBeenCalledTimes(1)
+})
+
+it('should release the lock even when closing fails',async()=>{
+closeNuxt.mockRejectedValue(newError('nitro would not close'))
+
+const{ close }=awaitinitialize(context())
+
+awaitexpect(close()).rejects.toThrow('nitro would not close')
+expect(releaseLock).toHaveBeenCalledTimes(1)
+})
+
+it('should reload in place when asked',async()=>{
+const{ reload }=awaitinitialize(context())
+
+awaitreload({type: 'shortcut'})
+
+expect(devServers[0].load).toHaveBeenCalledWith(true,{type: 'shortcut'})
+})
+
+it('should pass `extends` through to the dev server overrides',async()=>{
+awaitinitialize(context({extends: ['../layer']}))
+
+expect(devServers[0].options.overrides).toMatchObject({extends: ['../layer']})
+})
+
+it('should not profile unless it was asked to',async()=>{
+awaitinitialize(context())
+
+expect(startCpuProfile).not.toHaveBeenCalled()
+expect(devServers[0].options.overrides.debug).toBeUndefined()
+})
+
+it('should profile quietly for a bare `--profile`',async()=>{
+awaitinitialize(context({profile: ''}))
+
+expect(startCpuProfile).toHaveBeenCalledTimes(1)
+expect(devServers[0].options.overrides).toMatchObject({debug: {perf: 'quiet'}})
+})
+
+it('should profile verbosely for `--profile=verbose`',async()=>{
+awaitinitialize(context({profile: 'verbose'}))
+
+expect(devServers[0].options.overrides).toMatchObject({debug: {perf: true}})
+})
+
+it('should hand the file change and restart hooks to the caller',async()=>{
+const{ onFileChange, onRestart }=awaitinitialize(context())
+constchanged=vi.fn()
+constrestarted=vi.fn()
+
+onFileChange(changed)
+onRestart(restarted)
+devServers[0].emit('change')
+devServers[0].emit('restart',{type: 'hook'})
+
+expect(changed).toHaveBeenCalledTimes(1)
+expect(restarted).toHaveBeenCalledWith({type: 'hook'})
+})
+})