test: cover typecheck checker selection, install advice and build mode

Author: danielroe

packages/nuxt-cli/test/unit/commands/typecheck.spec.ts

@@ -1,94 +1,221 @@
-import{fileURLToPath}from'node:url'
-
-import{beforeEach,describe,expect,it,vi}from'vitest'
-
-import{runCommand}from'../../../src/run'
-import{logger}from'../../../src/utils/logger'
-
-const{ buildNuxt, closeNuxt, loadKit, resolveModulePath, writeTypes, x }=vi.hoisted(()=>{
-constbuildNuxt=vi.fn(()=>Promise.resolve())
-constcloseNuxt=vi.fn(()=>Promise.resolve())
-constwriteTypes=vi.fn(()=>Promise.resolve())
-return{
- buildNuxt,
- closeNuxt,
+import{mkdir,mkdtemp,readFile,rm,writeFile}from'node:fs/promises'
+import{tmpdir}from'node:os'
+importprocessfrom'node:process'
+
+import{join}from'pathe'
+import{afterEach,beforeEach,describe,expect,it,vi}from'vitest'
+
+const{ addDevDependency, answers, resolveModulePath, tinyexec, writeTypes }=vi.hoisted(()=>({
+addDevDependency: vi.fn(()=>Promise.resolve()),
+answers: {select: []asunknown[],confirm: []asunknown[]},
+resolveModulePath: vi.fn(),
+tinyexec: vi.fn(()=>Promise.resolve({exitCode: 0,stdout: '',stderr: ''})),
+writeTypes: vi.fn(()=>Promise.resolve()),
+}))
+
+vi.mock('tinyexec',()=>({x: tinyexec}))
+
+vi.mock('exsolve',asyncimportOriginal=>({
+ ...awaitimportOriginal<typeofimport('exsolve')>(),
+ resolveModulePath,
+}))
+
+vi.mock('nypm',asyncimportOriginal=>({
+ ...awaitimportOriginal<typeofimport('nypm')>(),
+ addDevDependency,
+detectPackageManager: ()=>Promise.resolve({name: 'pnpm',command: 'pnpm'}),
+}))
+
+vi.mock('../../../src/utils/kit',()=>({
+loadKit: ()=>Promise.resolve({
+loadNuxt: ()=>Promise.resolve({close: ()=>Promise.resolve(),options: {}}),
+buildNuxt: ()=>Promise.resolve(),
  writeTypes,
-x: vi.fn((_bin: string,_args: string[])=>Promise.resolve({exitCode: 0})),
-loadKit: vi.fn(()=>Promise.resolve({
-loadNuxt: ()=>Promise.resolve({close: closeNuxt}),
- buildNuxt,
- writeTypes,
-})),
-resolveModulePath: vi.fn((id: string): string|undefined=>id.includes('vue-tsc') ? '/node_modules/vue-tsc/bin/vue-tsc.js' : '/node_modules/typescript/index.js'),
+}),
+tryResolveNuxt: ()=>undefined,
+}))
+
+vi.mock('std-env',asyncimportOriginal=>({
+ ...awaitimportOriginal<typeofimport('std-env')>(),
+hasTTY: true,
+}))
+
+vi.mock('@clack/prompts',async(importOriginal)=>{
+constoriginal=awaitimportOriginal<typeofimport('@clack/prompts')>()
+constnext=(queue: unknown[],fallback: unknown)=>Promise.resolve(queue.length ? queue.shift() : fallback)
+return{
+ ...original,
+select: vi.fn(()=>next(answers.select,'vue-tsc')),
+confirm: vi.fn(()=>next(answers.confirm,false)),
+spinner: vi.fn(()=>({start: vi.fn(),stop: vi.fn(),error: vi.fn(),message: vi.fn()})),
 }
 })
 
-vi.mock('tinyexec',()=>({ x }))
-vi.mock('../../../src/utils/kit',()=>({ loadKit }))
-vi.mock('exsolve',()=>({ resolveModulePath }))
+const{ runCommandDef }=awaitimport('../../../src/run-command')
+const{ render, screen }=awaitimport('../../utils/terminal')
+consttypecheck=awaitimport('../../../src/commands/typecheck').then(r=>r.default)
 
-functionfixture(name: string){
-returnfileURLToPath(newURL(`../../fixtures/typecheck/${name}`,import.meta.url))
+letcwd: string
+
+/** Pretend the named packages are installed in the project. */
+functioninstalled(...names: string[]): void{
+resolveModulePath.mockImplementation((id: string)=>{
+if(names.some(name=>id===name||id.startsWith(`${name}/`))){
+returnjoin(cwd,'node_modules',id)
+}
+returnundefined
+})
 }
 
-asyncfunctionrun(cwd: string, ...args: string[]){
-awaitrunCommand('typecheck',['--cwd',cwd, ...args])
-returnx.mock.calls[0]?.[1]
+asyncfunctionrunTypecheck(argv: string[]=[]): Promise<{output: string,exitCode: number|undefined}>{
+process.exitCode=undefined
+constrenderer=awaitrender(async()=>{
+awaitrunCommandDef(typecheck,[`--cwd=${cwd}`, ...argv])
+})
+constexitCode=process.exitCodeasnumber|undefined
+process.exitCode=0
+return{output: `${renderer.frames.join('\n')}\n${screen(renderer)}`, exitCode }
 }
 
-describe('nuxt typecheck command',()=>{
-beforeEach(()=>{
-vi.clearAllMocks()
-process.exitCode=undefined
-resolveModulePath.mockImplementation((id: string)=>id.includes('vue-tsc') ? '/node_modules/vue-tsc/bin/vue-tsc.js' : '/node_modules/typescript/index.js')
-x.mockResolvedValue({exitCode: 0})
+beforeEach(async()=>{
+cwd=awaitmkdtemp(join(tmpdir(),'nuxt-typecheck-'))
+answers.select.length=0
+answers.confirm.length=0
+vi.clearAllMocks()
+tinyexec.mockResolvedValue({exitCode: 0,stdout: '',stderr: ''})
+addDevDependency.mockImplementation(()=>Promise.resolve())
+installed('typescript','vue-tsc/bin/vue-tsc.js')
+awaitwriteFile(join(cwd,'package.json'),JSON.stringify({name: 'app',type: 'module'}))
+})
+
+afterEach(async()=>{
+awaitrm(cwd,{recursive: true,force: true})
+vi.restoreAllMocks()
+})
+
+describe('typecheck checker selection',()=>{
+it('should reject a checker it does not know',async()=>{
+const{ output, exitCode }=awaitrunTypecheck(['--checker=tsc'])
+
+expect(exitCode).toBe(1)
+expect(output).toContain('Unknown type checker')
+expect(output).toContain('vue-tsc')
+expect(tinyexec).not.toHaveBeenCalled()
+})
+
+it('should run the checker that is installed',async()=>{
+awaitrunTypecheck()
+
+expect(tinyexec).toHaveBeenCalledWith(expect.stringContaining('vue-tsc'),['--noEmit'],expect.objectContaining({
+nodeOptions: expect.objectContaining({ cwd }),
+}))
+})
+
+it('should prefer golar when the project has a golar config',async()=>{
+awaitwriteFile(join(cwd,'golar.config.ts'),'export default {}')
+awaitmkdir(join(cwd,'node_modules/golar'),{recursive: true})
+awaitwriteFile(join(cwd,'node_modules/golar/package.json'),JSON.stringify({name: 'golar',bin: './bin.js'}))
+installed('typescript','vue-tsc/bin/vue-tsc.js','golar/unstable','@golar/vue')
+
+awaitrunTypecheck()
+
+expect(tinyexec).toHaveBeenCalledWith(expect.stringContaining('golar'),['tsc','--noEmit'],expect.anything())
 })
 
-it('should use build mode for Nuxt project references',async()=>{
-expect(awaitrun(fixture('nuxt-references'))).toEqual(['-b','--noEmit'])
+it('should create a golar config the first time golar is used',async()=>{
+awaitmkdir(join(cwd,'node_modules/golar'),{recursive: true})
+awaitwriteFile(join(cwd,'node_modules/golar/package.json'),JSON.stringify({name: 'golar',bin: './bin.js'}))
+installed('golar/unstable','@golar/vue')
+
+awaitrunTypecheck(['--checker=golar'])
+
+expect(awaitreadFile(join(cwd,'golar.config.ts'),'utf8')).toContain('defineConfig')
 })
+})
 
-it('should not use build mode when the tsconfig has input files of its own',async()=>{
-expect(awaitrun(fixture('legacy-references/app'))).toEqual(['--noEmit'])
+describe('typecheck installation advice',()=>{
+it('should offer to install a missing checker and run it afterwards',async()=>{
+installed()
+answers.select.push('vue-tsc')
+answers.confirm.push(true)
+addDevDependency.mockImplementation(()=>{
+installed('typescript','vue-tsc/bin/vue-tsc.js')
+returnPromise.resolve()
+})
+
+awaitrunTypecheck()
+
+expect(addDevDependency).toHaveBeenCalledWith(['typescript','vue-tsc'],expect.objectContaining({ cwd }))
+expect(tinyexec).toHaveBeenCalledTimes(1)
 })
 
-it('should respect an explicit --build flag',async()=>{
-expect(awaitrun(fixture('legacy-references/app'),'--build')).toEqual(['-b','--noEmit'])
+it('should print the install command when the user declines',async()=>{
+installed()
+answers.select.push('vue-tsc')
+answers.confirm.push(false)
+
+const{ output, exitCode }=awaitrunTypecheck()
+
+expect(exitCode).toBe(1)
+expect(output).toContain('pnpm add -D typescript vue-tsc')
+expect(tinyexec).not.toHaveBeenCalled()
 })
 
-it('should respect an explicit --no-build flag',async()=>{
-expect(awaitrun(fixture('nuxt-references'),'--no-build')).toEqual(['--noEmit'])
+it('should explain when the checker is still missing after installing',async()=>{
+installed()
+answers.select.push('vue-tsc')
+answers.confirm.push(true)
+
+const{ output, exitCode }=awaitrunTypecheck()
+
+expect(exitCode).toBe(1)
+expect(output).toContain('Failed to resolve')
+expect(tinyexec).not.toHaveBeenCalled()
 })
+})
+
+describe('typecheck build mode',()=>{
+it('should use project references for a solution-style tsconfig',async()=>{
+awaitwriteFile(join(cwd,'tsconfig.json'),JSON.stringify({files: [],references: [{path: './.nuxt/tsconfig.app.json'}]}))
+
+awaitrunTypecheck()
 
-it('should warn when Nuxt project references are referenced alongside input files',async()=>{
-constwarn=vi.spyOn(logger,'warn').mockImplementation(()=>{})
-awaitrun(fixture('incomplete-references'))
-expect(warn).toHaveBeenCalledWith(expect.stringContaining('"files": []'))
-warn.mockRestore()
+expect(tinyexec).toHaveBeenCalledWith(expect.anything(),['-b','--noEmit'],expect.anything())
 })
 
-it('should not prepare Nuxt when the requested checker is unavailable',async()=>{
-resolveModulePath.mockReturnValue(undefined)
+it('should warn when a tsconfig references nuxt projects but has files of its own',async()=>{
+awaitwriteFile(join(cwd,'tsconfig.json'),JSON.stringify({
+include: ['src'],
+references: [{path: './.nuxt/tsconfig.app.json'}],
+}))
 
-awaitrun(fixture('nuxt-references'),'--checker','vue-tsc')
+const{ output }=awaitrunTypecheck()
 
-expect(process.exitCode).toBe(1)
-expect(loadKit).not.toHaveBeenCalled()
+expect(output).toContain('"files": []')
+expect(tinyexec).toHaveBeenCalledWith(expect.anything(),['--noEmit'],expect.anything())
 })
 
-it('should close Nuxt when preparing types fails',async()=>{
-writeTypes.mockRejectedValueOnce(newError('could not write types'))
+it('should let `--build` override the detection',async()=>{
+awaitrunTypecheck(['--build'])
+
+expect(tinyexec).toHaveBeenCalledWith(expect.anything(),['-b','--noEmit'],expect.anything())
+})
+})
+
+describe('typecheck results',()=>{
+it('should report a passing type check',async()=>{
+const{ output, exitCode }=awaitrunTypecheck()
 
-awaitexpect(run(fixture('nuxt-references'))).rejects.toThrow('could not write types')
-expect(buildNuxt).not.toHaveBeenCalled()
-expect(closeNuxt).toHaveBeenCalledOnce()
+expect(output).toContain('Type check passed')
+expect(exitCode).toBeFalsy()
 })
 
-it('should propagate the checker exit code',async()=>{
-x.mockResolvedValueOnce({exitCode: 2})
+it('should carry the checker exit code through',async()=>{
+tinyexec.mockResolvedValue({exitCode: 2,stdout: '',stderr: ''})
 
-awaitrun(fixture('nuxt-references'))
+const{ output, exitCode }=awaitrunTypecheck()
 
-expect(process.exitCode).toBe(2)
+expect(output).toContain('Type check failed')
+expect(exitCode).toBe(2)
 })
 })