test: cover console raw mode, config loading and info box formatting

Author: danielroe

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

@@ -0,0 +1,105 @@
+importprocessfrom'node:process'
+
+import{consola}from'consola'
+import{afterEach,describe,expect,it,vi}from'vitest'
+
+import{restoreRawMode,withDirectStdout}from'../../../src/utils/console'
+
+conststdin=process.stdinasNodeJS.ReadStream&{isTTY?: boolean,isRaw?: boolean}
+constdescriptors=Object.getOwnPropertyDescriptors(stdin)
+
+constsetRawMode=vi.fn(()=>stdin)
+
+functionstubStdin(properties: {isTTY?: boolean,isRaw?: boolean}): void{
+setRawMode.mockClear()
+Object.defineProperty(stdin,'setRawMode',{value: setRawMode,configurable: true,writable: true})
+for(const[key,value]ofObject.entries(properties)){
+Object.defineProperty(stdin,key,{ value,configurable: true,writable: true})
+}
+}
+
+afterEach(()=>{
+vi.restoreAllMocks()
+for(constkeyof['isTTY','isRaw','setRawMode']asconst){
+if(descriptors[key]){
+Object.defineProperty(stdin,key,descriptors[key])
+}
+else{
+delete(stdinasRecord<string,unknown>)[key]
+}
+}
+})
+
+describe('restoreRawMode',()=>{
+it('should do nothing when stdin is not a tty',()=>{
+stubStdin({isTTY: false})
+
+restoreRawMode()
+
+expect(setRawMode).not.toHaveBeenCalled()
+})
+
+it('should leave raw mode and resume a paused stdin',()=>{
+stubStdin({isTTY: true,isRaw: true})
+vi.spyOn(stdin,'isPaused').mockReturnValue(true)
+constresume=vi.spyOn(stdin,'resume').mockReturnValue(stdin)
+
+restoreRawMode()
+
+expect(resume).toHaveBeenCalled()
+expect(setRawMode).toHaveBeenCalledWith(false)
+})
+
+it('should not touch a tty that is already out of raw mode',()=>{
+stubStdin({isTTY: true,isRaw: false})
+vi.spyOn(stdin,'isPaused').mockReturnValue(false)
+
+restoreRawMode()
+
+expect(setRawMode).not.toHaveBeenCalled()
+})
+})
+
+describe('withDirectStdout',()=>{
+it('should run the callback unchanged when stdout is not wrapped',async()=>{
+constrestore=vi.spyOn(consola,'restoreStd')
+
+awaitexpect(withDirectStdout(()=>'result')).resolves.toBe('result')
+expect(restore).not.toHaveBeenCalled()
+})
+
+it('should unwrap stdout for the callback and wrap it again afterwards',async()=>{
+constwrapped=process.stdoutastypeofprocess.stdout&{__write?: typeofprocess.stdout.write}
+constoriginal=wrapped.__write
+wrapped.__write=(()=>true)astypeofprocess.stdout.write
+constrestore=vi.spyOn(consola,'restoreStd').mockImplementation(()=>{})
+constwrap=vi.spyOn(consola,'wrapStd').mockImplementation(()=>{})
+
+try{
+awaitexpect(withDirectStdout(()=>'result')).resolves.toBe('result')
+expect(restore).toHaveBeenCalled()
+expect(wrap).toHaveBeenCalled()
+}
+finally{
+wrapped.__write=original
+}
+})
+
+it('should wrap stdout again when the callback throws',async()=>{
+constwrapped=process.stdoutastypeofprocess.stdout&{__write?: typeofprocess.stdout.write}
+constoriginal=wrapped.__write
+wrapped.__write=(()=>true)astypeofprocess.stdout.write
+vi.spyOn(consola,'restoreStd').mockImplementation(()=>{})
+constwrap=vi.spyOn(consola,'wrapStd').mockImplementation(()=>{})
+
+try{
+awaitexpect(withDirectStdout(()=>{
+thrownewError('boom')
+})).rejects.toThrow('boom')
+expect(wrap).toHaveBeenCalled()
+}
+finally{
+wrapped.__write=original
+}
+})
+})

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

@@ -0,0 +1,41 @@
+import{stripVTControlCharacters}from'node:util'
+
+import{describe,expect,it}from'vitest'
+
+import{formatInfoBox}from'../../../src/utils/formatting'
+
+functionplain(box: string): string[]{
+returnstripVTControlCharacters(box).split('\n').map(line=>line.trimEnd())
+}
+
+describe('formatInfoBox',()=>{
+it('should render one line per entry',()=>{
+expect(plain(formatInfoBox({Nuxt: '4.0.0',CLI: '4.0.0'}))).toEqual([
+expect.stringMatching(/^Nuxt+4\.0\.0$/),
+expect.stringMatching(/^CLI+4\.0\.0$/),
+'',
+])
+})
+
+it('should render a placeholder for a missing value',()=>{
+expect(plain(formatInfoBox({Builder: undefined}))).toEqual([expect.stringMatching(/^Builder+-$/),''])
+})
+
+it('should strip backticks from values',()=>{
+expect(plain(formatInfoBox({Modules: '`@nuxt/image`'}))).toEqual([expect.stringMatching(/^Modules+@nuxt\/image$/),''])
+})
+
+it('should align values to the widest label',()=>{
+const[first,second]=plain(formatInfoBox({A: 'x',LongerLabel: 'y'}))
+
+expect(first!.indexOf('x')).toBe(second!.indexOf('y'))
+})
+
+it('should wrap a long value onto continuation lines',()=>{
+constvalue=Array.from({length: 40},(_,index)=>`module-${index}`).join(' ')
+constlines=plain(formatInfoBox({Modules: value})).filter(Boolean)
+
+expect(lines.length).toBeGreaterThan(1)
+expect(lines.slice(1).every(line=>line.startsWith(' '))).toBe(true)
+})
+})

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

@@ -1,106 +1,66 @@
-import{execFile}from'node:child_process'
-import{mkdtemp,writeFile}from'node:fs/promises'
+import{mkdtemp,rm,writeFile}from'node:fs/promises'
 import{tmpdir}from'node:os'
 import{join}from'node:path'
-importprocessfrom'node:process'
 
-import{promisify}from'node:util'
+import{consola}from'consola'
+import{afterEach,beforeEach,describe,expect,it,vi}from'vitest'
 
-import{describe,expect,it}from'vitest'
+import{CONFIG_EXTENSIONS,getNuxtConfig}from'../../../src/utils/nuxt-config'
 
-constexecFileAsync=promisify(execFile)
+letroot: string
 
-constloaderUrl=newURL('../../../src/utils/nuxt-config.ts',import.meta.url).href
-
-/**
- * `getNuxtConfig` picks between Node's own loader and `jiti` by inspecting the
- * error codes Node raises, and Vitest resolves dynamic imports through Vite
- * rather than Node. Every case therefore runs in a real Node process, otherwise
- * the branch under test is never the one taken.
- */
-asyncfunctionloadConfig(files: Record<string,string>){
-constcwd=awaitmkdtemp(join(tmpdir(),'nuxi-nuxt-config-'))
-for(const[name,contents]ofObject.entries(files)){
-awaitwriteFile(join(cwd,name),contents,'utf8')
-}
+beforeEach(async()=>{
+root=awaitmkdtemp(join(tmpdir(),'nuxt-config-'))
+})
 
-constscript=`
- const { getNuxtConfig } = await import(${JSON.stringify(loaderUrl)})
- process.stdout.write(JSON.stringify(await getNuxtConfig(${JSON.stringify(cwd)})))
- `
-const{ stdout, stderr }=awaitexecFileAsync(process.execPath,['--input-type=module','--eval',script],{ cwd })
-return{config: JSON.parse(stdout), stderr }
-}
+afterEach(async()=>{
+vi.restoreAllMocks()
+awaitrm(root,{recursive: true,force: true})
+})
 
 describe('getNuxtConfig',()=>{
-it('should load a config with Node\'s own loader',async()=>{
-const{ config }=awaitloadConfig({
-'package.json': '{"name":"native","type":"module"}',
-'nuxt.config.ts': 'export default defineNuxtConfig({ modules: [\'@nuxt/image\'] })\n',
-})
-
-expect(config).toMatchObject({modules: ['@nuxt/image']})
+it('should list the extensions a config can have',()=>{
+expect(CONFIG_EXTENSIONS).toContain('.ts')
+expect(CONFIG_EXTENSIONS).toContain('.mjs')
 })
 
-it('should strip erasable types',async()=>{
-const{ config }=awaitloadConfig({
-'package.json': '{"name":"typed","type":"module"}',
-'nuxt.config.ts': 'const ssr: boolean = false\nexport default defineNuxtConfig({ ssr })\n',
-})
-
-expect(config).toMatchObject({ssr: false})
+it('should return an empty object when there is no config',async()=>{
+awaitexpect(getNuxtConfig(root)).resolves.toEqual({})
 })
 
-it('should fall back to `jiti` for aliases Node cannot resolve',async()=>{
-const{ config }=awaitloadConfig({
-'package.json': '{"name":"aliased","type":"module"}',
-'module.ts': 'export const mod = \'@nuxt/content\'\n',
-'nuxt.config.ts': 'import { mod } from \'~/module\'\n\nexport default defineNuxtConfig({ modules: [mod] })\n',
-})
+it('should read a plain esm config',async()=>{
+awaitwriteFile(join(root,'nuxt.config.mjs'),'export default { buildDir: ".custom" }')
 
-expect(config).toMatchObject({modules: ['@nuxt/content']})
+awaitexpect(getNuxtConfig(root)).resolves.toMatchObject({buildDir: '.custom'})
 })
 
-it('should fall back to `jiti` for TypeScript that cannot be stripped',async()=>{
-const{ config }=awaitloadConfig({
-'package.json': '{"name":"enums","type":"module"}',
-'nuxt.config.ts': 'enum Mod { Image = \'@nuxt/image\' }\n\nexport default defineNuxtConfig({ modules: [Mod.Image] })\n',
-})
+it('should read a config using the global defineNuxtConfig',async()=>{
+awaitwriteFile(join(root,'nuxt.config.mjs'),'export default defineNuxtConfig({ buildDir: ".defined" })')
 
-expect(config).toMatchObject({modules: ['@nuxt/image']})
+awaitexpect(getNuxtConfig(root)).resolves.toMatchObject({buildDir: '.defined'})
 })
 
-it('should load a plain JavaScript config',async()=>{
-const{ config }=awaitloadConfig({
-'package.json': '{"name":"plain","type":"module"}',
-'nuxt.config.mjs': 'export default defineNuxtConfig({ ssr: false })\n',
-})
-
-expect(config).toMatchObject({ssr: false})
-})
+it('should not leak defineNuxtConfig onto globalThis',async()=>{
+awaitwriteFile(join(root,'nuxt.config.mjs'),'export default { buildDir: ".custom" }')
 
-it('should return an empty config when there is no config file',async()=>{
-const{ config }=awaitloadConfig({'package.json': '{"name":"bare","type":"module"}'})
+awaitgetNuxtConfig(root)
 
-expect(config).toEqual({})
+expect((globalThisasRecord<string,unknown>).defineNuxtConfig).toBeUndefined()
 })
 
-it('should return an empty config when the config throws',async()=>{
-const{config}=awaitloadConfig({
-'package.json': '{"name":"broken","type":"module"}',
-'nuxt.config.ts': 'throw new Error(\'boom\')\n',
-})
+it('should warn and return an empty config when the config throws',async()=>{
+awaitwriteFile(join(root,'nuxt.config.mjs'),'throw new Error("broken config")')
+constwarn=vi.spyOn(consola,'warn').mockImplementation(()=>{})
+
+awaitexpect(getNuxtConfig(root)).resolves.toEqual({})
 
-expect(config).toEqual({})
+expect(warn).toHaveBeenCalledTimes(1)
+expect(warn.mock.calls[0]![0]).toContain('broken config')
 })
 
-it('should not warn about module type for a config without `type: module`',async()=>{
-const{ config, stderr }=awaitloadConfig({
-'package.json': '{"name":"typeless"}',
-'nuxt.config.ts': 'export default defineNuxtConfig({ ssr: true })\n',
-})
+it('should read a typescript config',async()=>{
+awaitwriteFile(join(root,'nuxt.config.ts'),'export default { buildDir: ".ts-build" } as Record<string, string>')
 
-expect(config).toMatchObject({ssr: true})
-expect(stderr).not.toContain('MODULE_TYPELESS_PACKAGE_JSON')
+awaitexpect(getNuxtConfig(root)).resolves.toMatchObject({buildDir: '.ts-build'})
 })
 })