From a41af44ade51d56c0607957792b06d4505b9a8d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=B1=AA=E7=A3=8A?= <w@zce.me>
Date: Wed, 26 Jul 2023 15:37:32 +0800
Subject: [PATCH] test: replace jest with vitest (#156)

* test: replace jest with vitest

* chore: remove built-in modules prefix

* chore: version bump to v2.0.0-beta.0
---
 .github/workflows/main.yml | 17 ++++----
 package.json               | 57 ++++++++++----------------
 src/cli.spec.ts            | 48 +---------------------
 src/cli.ts                 |  1 -
 src/complete.spec.ts       | 13 +++---
 src/confirm.spec.ts        | 84 +++++++++++++++-----------------------
 src/core/config.spec.ts    | 19 ++++-----
 src/core/exec.spec.ts      |  2 +-
 src/core/file.spec.ts      | 22 +++++-----
 src/core/file.ts           |  6 +--
 src/core/http.spec.ts      |  8 ++--
 src/core/http.ts           |  4 +-
 src/core/index.spec.ts     |  2 +-
 src/core/ware.spec.ts      |  2 +-
 src/emit.spec.ts           | 10 ++---
 src/index.spec.ts          | 26 ++++++------
 src/init.spec.ts           | 16 ++++----
 src/inquire.spec.ts        | 64 ++++++++++++++---------------
 src/inquire.ts             |  4 +-
 src/install.spec.ts        | 18 ++++----
 src/install.ts             |  2 +-
 src/list/fetch.spec.ts     |  2 +-
 src/list/index.spec.ts     | 14 +++----
 src/load.spec.ts           |  6 +--
 src/load.ts                |  2 +-
 src/prepare.spec.ts        |  4 +-
 src/rename.spec.ts         |  2 +-
 src/render.spec.ts         |  2 +-
 src/resolve.spec.ts        | 19 ++++-----
 src/setup.spec.ts          |  4 +-
 test/helpers.ts            | 10 ++---
 31 files changed, 204 insertions(+), 286 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 403a348d..84f9a2ef 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -3,28 +3,29 @@ name: CI
 on: [push, pull_request]
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
+  test:
     strategy:
       matrix:
-        node-version: [14, 16, 17, 18]
+        os: [ubuntu-latest, windows-latest]
+        node: [16, 18, 20]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: ${{ matrix.node }}
       - run: npm i pnpm yarn -g
       - run: git config --global user.name "GitHub Actions"
       - run: git config --global user.email "bots@github.com"
       - run: npm install
-      - run: npm run lint
-      - run: npm run build
-      - run: npm run test
+      - run: npm i @vitest/coverage-v8
+      - run: npx ts-standard
+      - run: npx vitest run --coverage
       - run: npx codecov
 
   publish:
     if: startsWith(github.ref, 'refs/tags')
-    needs: build
+    needs: test
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
diff --git a/package.json b/package.json
index 690820a0..3f7ec86e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "caz",
-  "version": "1.1.0",
+  "version": "2.0.0-beta.0",
   "description": "A simple yet powerful template-based Scaffolding tools.",
   "keywords": [
     "productivity",
@@ -37,7 +37,7 @@
   "scripts": {
     "build": "tsup",
     "lint": "ts-standard",
-    "test": "jest --coverage",
+    "test": "vitest run",
     "prepare": "husky install .github/husky"
   },
   "tsup": {
@@ -49,8 +49,8 @@
     "minify": true,
     "splitting": true,
     "dts": {
-      "resolve": true,
-      "entry": "src/index.ts"
+      "entry": "src/index.ts",
+      "resolve": true
     }
   },
   "commitlint": {
@@ -61,55 +61,40 @@
   "lint-staged": {
     "*.{ts,js}": "ts-standard --fix"
   },
-  "jest": {
-    "preset": "ts-jest/presets/js-with-ts",
-    "testTimeout": 20000,
-    "testEnvironment": "node",
-    "collectCoverageFrom": [
-      "src/**"
-    ],
-    "moduleNameMapper": {
-      "#(.*)": "<rootDir>/node_modules/$1"
-    },
-    "transformIgnorePatterns": [
-      "node_modules/(?!(node-fetch|fetch-blob|formdata-polyfill|data-uri-to-buffer|env-paths|ora|cli-cursor|restore-cursor|chalk|log-symbols|is-unicode-supported|is-interactive|strip-ansi|ansi-regex))"
-    ]
-  },
   "renovate": {
     "extends": [
       "zce"
     ]
   },
   "devDependencies": {
-    "@commitlint/cli": "17.4.2",
-    "@commitlint/config-conventional": "17.4.2",
+    "@commitlint/cli": "17.6.7",
+    "@commitlint/config-conventional": "17.6.7",
     "@types/adm-zip": "0.5.0",
     "@types/ini": "1.3.31",
-    "@types/lodash": "4.14.191",
-    "@types/node": "18.11.18",
-    "@types/semver": "7.3.13",
+    "@types/lodash": "4.14.195",
+    "@types/node": "20.4.4",
+    "@types/semver": "7.5.0",
     "@types/validate-npm-package-name": "4.0.0",
     "adm-zip": "0.5.10",
     "cac": "6.7.14",
     "env-paths": "3.0.0",
-    "fast-glob": "3.2.12",
+    "fast-glob": "3.3.1",
     "husky": "8.0.3",
-    "ini": "3.0.1",
-    "jest": "29.4.1",
-    "lint-staged": "13.1.0",
+    "ini": "4.1.1",
+    "lint-staged": "13.2.3",
     "lodash": "4.17.21",
-    "node-fetch": "3.3.0",
-    "ora": "6.1.2",
+    "node-fetch": "3.3.1",
+    "ora": "6.3.1",
     "prompts": "2.4.2",
-    "semver": "7.3.8",
-    "socks-proxy-agent": "7.0.0",
-    "ts-jest": "29.0.5",
+    "semver": "7.5.4",
+    "socks-proxy-agent": "8.0.1",
     "ts-standard": "12.0.2",
-    "tsup": "6.5.0",
-    "typescript": "4.9.5",
-    "validate-npm-package-name": "5.0.0"
+    "tsup": "7.1.0",
+    "typescript": "5.1.6",
+    "validate-npm-package-name": "5.0.0",
+    "vitest": "0.33.0"
   },
   "engines": {
-    "node": ">=14.14"
+    "node": ">=16"
   }
 }
diff --git a/src/cli.spec.ts b/src/cli.spec.ts
index 0b6db054..b27dd2e8 100644
--- a/src/cli.spec.ts
+++ b/src/cli.spec.ts
@@ -1,7 +1,4 @@
-import { jest, test, expect, beforeEach, afterAll } from '@jest/globals'
-
-const mockedInit = jest.fn()
-const mockedList = jest.fn()
+import { vi, test, expect } from 'vitest'
 
 const mockArgv = (...args: string[]): () => void => {
   const original = process.argv
@@ -9,53 +6,12 @@ const mockArgv = (...args: string[]): () => void => {
   return () => { process.argv = original }
 }
 
-beforeEach(async () => {
-  jest.resetAllMocks()
-  jest.resetModules()
-  jest.mock('.', () => ({ __esModule: true, default: mockedInit, list: mockedList }))
-})
-
-afterAll(async () => {
-  jest.clearAllMocks()
-})
-
-test('unit:cli:init', async () => {
-  const restore = mockArgv('template', 'project', '--force', '--offline', '--foo', 'bar')
-  await import('./cli')
-  expect(mockedInit).toHaveBeenCalled()
-  expect(mockedInit.mock.calls[0][0]).toBe('template')
-  expect(mockedInit.mock.calls[0][1]).toBe('project')
-  expect(mockedInit.mock.calls[0][2]).toEqual({ '--': [], f: true, force: true, o: true, offline: true, foo: 'bar' })
-  restore()
-})
-
-test('unit:cli:list', async () => {
-  const restore = mockArgv('list', 'zce', '--json', '--short')
-  await import('./cli')
-  expect(mockedList).toHaveBeenCalled()
-  expect(mockedList.mock.calls[0][0]).toBe('zce')
-  expect(mockedList.mock.calls[0][1]).toEqual({ '--': [], j: true, json: true, s: true, short: true })
-  restore()
-})
-
 test('unit:cli:help', async () => {
   const restore = mockArgv('--help')
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await import('./cli')
   expect(log).toHaveBeenCalledTimes(1)
   expect(log.mock.calls[0][0]).toContain('$ caz <template> [project]')
   log.mockRestore()
   restore()
 })
-
-// // TODO: error
-// // https://github.com/facebook/jest/issues/5620
-// test('unit:cli:error', async () => {
-//   const error = jest.spyOn(console, 'error')
-//   const exit = jest.spyOn(process, 'exit')
-//   const restore = mockArgv()
-//   await import('./cli')
-//   expect(error).toHaveBeenCalled()
-//   expect(exit).toHaveBeenCalled()
-//   restore()
-// })
diff --git a/src/cli.ts b/src/cli.ts
index 54f34a4d..2dc07330 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -28,7 +28,6 @@ cli
 cli.help().version(version).parse()
 
 // https://github.com/cacjs/cac#error-handling
-/* istanbul ignore next */
 const onError = (err: Error): void => {
   // output details when exception occurs
   cli.options.debug as boolean && console.error(err)
diff --git a/src/complete.spec.ts b/src/complete.spec.ts
index 59740d65..c0e1df1b 100644
--- a/src/complete.spec.ts
+++ b/src/complete.spec.ts
@@ -1,13 +1,12 @@
-import { SpyInstance } from 'jest-mock'
-import { jest, test, expect, beforeEach, afterEach } from '@jest/globals'
+import { vi, test, expect, beforeEach, afterEach, SpyInstance } from 'vitest'
 import { context } from '../test/helpers'
 import complete from './complete'
 import { Context } from './types'
 
-let log: SpyInstance<(message?: any, ...optionalParams: any[]) => void>
+let log: SpyInstance<[message?: any, ...optionalParams: any[]], void>
 
 beforeEach(async () => {
-  log = jest.spyOn(console, 'log')
+  log = vi.spyOn(console, 'log')
 })
 
 afterEach(async () => {
@@ -39,7 +38,7 @@ test('unit:complete:string', async () => {
 })
 
 test('unit:complete:callback', async () => {
-  const callback = jest.fn<(ctx: Context) => string | Promise<string> | Promise<void>>()
+  const callback = vi.fn<(ctx: Context) => string | Promise<string> | Promise<void>>()
   const ctx = context({}, { complete: callback })
   await complete(ctx)
   expect(callback.mock.calls[0][0]).toBe(ctx)
@@ -47,7 +46,7 @@ test('unit:complete:callback', async () => {
 
 test('unit:complete:callback-return', async () => {
   // eslint-disable-next-line @typescript-eslint/no-extra-parens
-  const callback = jest.fn<(ctx: Context) => string | Promise<string> | Promise<void>>(() => 'completed')
+  const callback = vi.fn<(ctx: Context) => string | Promise<string> | Promise<void>>(() => 'completed')
   const ctx = context({}, { complete: callback })
   await complete(ctx)
   expect(callback).toHaveBeenCalled()
@@ -56,7 +55,7 @@ test('unit:complete:callback-return', async () => {
 
 test('unit:complete:callback-promise', async () => {
   // eslint-disable-next-line @typescript-eslint/no-extra-parens
-  const callback = jest.fn<(ctx: Context) => string | Promise<string> | Promise<void>>(async () => 'completed')
+  const callback = vi.fn<(ctx: Context) => string | Promise<string> | Promise<void>>(async () => 'completed')
   const ctx = context({}, { complete: callback })
   await complete(ctx)
   expect(callback).toHaveBeenCalled()
diff --git a/src/confirm.spec.ts b/src/confirm.spec.ts
index 3d8a44e3..442264aa 100644
--- a/src/confirm.spec.ts
+++ b/src/confirm.spec.ts
@@ -1,45 +1,39 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
 import prompts from 'prompts'
-import { test, expect, beforeAll, afterAll } from '@jest/globals'
-import { context, destory, mktmpdir } from '../test/helpers'
+import { vi, test, expect, beforeAll, afterAll, SpyInstance } from 'vitest'
+import { context, destory, exists, mktmpdir } from '../test/helpers'
 import confirm from './confirm'
 
-const cwd = process.cwd()
+let tempcwd: string
+let mockcwd: SpyInstance<[], string>
 
 beforeAll(async () => {
-  process.chdir(await mktmpdir())
+  tempcwd = await mktmpdir()
+  mockcwd = vi.spyOn(process, 'cwd').mockReturnValue(tempcwd)
 })
 
 afterAll(async () => {
-  const temp = process.cwd()
-  process.chdir(cwd)
-  await destory(temp)
+  mockcwd.mockRestore()
+  await destory(tempcwd)
 })
 
 test('unit:confirm:not-exists', async () => {
-  const ctx = context({
-    project: 'not-exists'
-  })
+  const ctx = context({ project: 'not-exists' })
   await confirm(ctx)
   expect(ctx.dest).toBe(path.resolve('not-exists'))
 })
 
 test('unit:confirm:force', async () => {
-  await fs.promises.writeFile('force', '')
-  const ctx = context({
-    project: 'force',
-    options: { force: true }
-  })
+  await fs.writeFile(path.resolve('force'), '')
+  const ctx = context({ project: 'force', options: { force: true } })
   await confirm(ctx)
   expect(ctx.dest).toBe(path.resolve('force'))
 })
 
 test('unit:confirm:file', async () => {
-  await fs.promises.writeFile('file', '')
-  const ctx = context({
-    project: 'file'
-  })
+  await fs.writeFile(path.resolve('file'), '')
+  const ctx = context({ project: 'file' })
   expect.hasAssertions()
   try {
     await confirm(ctx)
@@ -49,21 +43,17 @@ test('unit:confirm:file', async () => {
 })
 
 test('unit:confirm:empty', async () => {
-  await fs.promises.mkdir('empty')
-  const ctx = context({
-    project: 'empty'
-  })
+  await fs.mkdir(path.resolve('empty'))
+  const ctx = context({ project: 'empty' })
   await confirm(ctx)
   expect(ctx.dest).toBe(path.resolve('empty'))
 })
 
 test('unit:confirm:sure', async () => {
-  await fs.promises.mkdir('sure')
-  await fs.promises.writeFile('sure/file', '')
+  await fs.mkdir(path.resolve('sure'))
+  await fs.writeFile(path.resolve('sure/file'), '')
   prompts.inject([false])
-  const ctx = context({
-    project: 'sure'
-  })
+  const ctx = context({ project: 'sure' })
   expect.hasAssertions()
   try {
     await confirm(ctx)
@@ -74,10 +64,8 @@ test('unit:confirm:sure', async () => {
 
 test('unit:confirm:sure-cwd', async () => {
   prompts.inject([false])
-  await fs.promises.writeFile('file', '')
-  const ctx = context({
-    project: '.'
-  })
+  await fs.writeFile(path.resolve('sure-cwd'), '')
+  const ctx = context({ project: '.' })
   expect.hasAssertions()
   try {
     await confirm(ctx)
@@ -87,41 +75,35 @@ test('unit:confirm:sure-cwd', async () => {
 })
 
 test('unit:confirm:merge', async () => {
-  await fs.promises.mkdir('merge')
-  await fs.promises.writeFile('merge/file', '')
+  await fs.mkdir(path.resolve('merge'))
+  await fs.writeFile(path.resolve('merge/file'), '')
   prompts.inject([true, 'merge'])
-  const ctx = context({
-    project: 'merge'
-  })
+  const ctx = context({ project: 'merge' })
   await confirm(ctx)
   expect(ctx.dest).toBe(path.resolve('merge'))
-  expect(fs.existsSync('merge/file')).toBe(true)
+  expect(await exists(path.resolve('merge/file'))).toBe(true)
 })
 
 test('unit:confirm:overwrite', async () => {
-  await fs.promises.mkdir('overwrite')
-  await fs.promises.writeFile('overwrite/file', '')
+  await fs.mkdir(path.resolve('overwrite'))
+  await fs.writeFile(path.resolve('overwrite/file'), '')
   prompts.inject([true, 'overwrite'])
-  const ctx = context({
-    project: 'overwrite'
-  })
+  const ctx = context({ project: 'overwrite' })
   await confirm(ctx)
   expect(ctx.dest).toBe(path.resolve('overwrite'))
-  expect(fs.existsSync('overwrite')).toBe(false)
+  expect(await exists(path.resolve('overwrite'))).toBe(false)
 })
 
 test('unit:confirm:cancel', async () => {
-  await fs.promises.mkdir('cancel')
-  await fs.promises.writeFile('cancel/file', '')
+  await fs.mkdir(path.resolve('cancel'))
+  await fs.writeFile(path.resolve('cancel/file'), '')
   prompts.inject([true, 'cancel'])
-  const ctx = context({
-    project: 'cancel'
-  })
+  const ctx = context({ project: 'cancel' })
   expect.hasAssertions()
   try {
     await confirm(ctx)
   } catch (e) {
     expect((e as Error).message).toBe('You have cancelled this task.')
-    expect(fs.existsSync('cancel/file')).toBe(true)
+    expect(await exists(path.resolve('cancel/file'))).toBe(true)
   }
 })
diff --git a/src/core/config.spec.ts b/src/core/config.spec.ts
index 7a3bf2c9..7afe8e82 100644
--- a/src/core/config.spec.ts
+++ b/src/core/config.spec.ts
@@ -1,10 +1,9 @@
 import os from 'os'
-import { SpyInstance } from 'jest-mock'
-import { jest, test, expect } from '@jest/globals'
+import { vi, test, expect, SpyInstance } from 'vitest'
 import { fixture } from '../../test/helpers'
 import config from './config'
 
-const mockHomedir = (): SpyInstance => jest.spyOn(os, 'homedir').mockImplementation(() => fixture(''))
+const mockHomedir = (): SpyInstance => vi.spyOn(os, 'homedir').mockImplementation(() => fixture(''))
 
 test('unit:core:config', async () => {
   expect(config.registry).toBe('https://github.com/{owner}/{name}/archive/refs/heads/{branch}.zip')
@@ -16,7 +15,7 @@ test('unit:core:config', async () => {
 
 test('unit:core:config:custom', async () => {
   const homedir = mockHomedir()
-  jest.resetModules()
+  vi.resetModules()
   const { default: conf } = await import('./config')
   expect(conf.registry).toBe('https://gitlab.com/{owner}/{name}/archive/refs/heads/{branch}.zip')
   expect(conf.official).toBe('faker')
@@ -27,27 +26,27 @@ test('unit:core:config:custom', async () => {
 })
 
 test('unit:core:config:env', async () => {
-  jest.resetModules()
+  vi.resetModules()
   process.env.ALL_PROXY = 'socks://127.0.0.1:11111'
   expect((await import('./config')).default.proxy).toBe('socks://127.0.0.1:11111')
 
-  jest.resetModules()
+  vi.resetModules()
   process.env.HTTPS_PROXY = 'socks://127.0.0.1:22222'
   expect((await import('./config')).default.proxy).toBe('socks://127.0.0.1:22222')
 
-  jest.resetModules()
+  vi.resetModules()
   process.env.https_proxy = 'socks://127.0.0.1:22222'
   expect((await import('./config')).default.proxy).toBe('socks://127.0.0.1:22222')
 
-  jest.resetModules()
+  vi.resetModules()
   process.env.HTTP_PROXY = 'socks://127.0.0.1:22222'
   expect((await import('./config')).default.proxy).toBe('socks://127.0.0.1:22222')
 
-  jest.resetModules()
+  vi.resetModules()
   process.env.http_proxy = 'socks://127.0.0.1:22222'
   expect((await import('./config')).default.proxy).toBe('socks://127.0.0.1:22222')
 
-  jest.resetModules()
+  vi.resetModules()
   process.env.NO_PROXY = '1'
   expect((await import('./config')).default.proxy).toBe(undefined)
 })
diff --git a/src/core/exec.spec.ts b/src/core/exec.spec.ts
index 9fa21eef..5539fe74 100644
--- a/src/core/exec.spec.ts
+++ b/src/core/exec.spec.ts
@@ -1,4 +1,4 @@
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import exec from './exec'
 
 test('unit:core:exec:normal', async () => {
diff --git a/src/core/file.spec.ts b/src/core/file.spec.ts
index 83f35e71..36d5e52a 100644
--- a/src/core/file.spec.ts
+++ b/src/core/file.spec.ts
@@ -1,7 +1,7 @@
 import os from 'os'
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { fixture, exists, mktmpdir, destory } from '../../test/helpers'
 import * as file from './file'
 
@@ -63,7 +63,7 @@ test('unit:core:file:mkdir', async () => {
   // mode options (recursive false dependency case 1)
   const target3 = temp + '/3'
   await file.mkdir(target3, { mode: 0o755, recursive: false })
-  const stat3 = await fs.promises.stat(target3)
+  const stat3 = await fs.stat(target3)
   if (process.platform !== 'win32') {
     expect(stat3.mode & 0o777).toBe(0o755)
   }
@@ -81,19 +81,19 @@ test('unit:core:file:remove', async () => {
 
   // remove a file
   const target2 = path.join(temp, 'caz-remove-2')
-  await fs.promises.writeFile(target2, '')
+  await fs.writeFile(target2, '')
   await file.remove(target2)
   expect(await exists(target2)).toBe(false)
 
   // remove a dir
   const target3 = path.join(temp, 'caz-remove-3')
-  await fs.promises.mkdir(target3)
+  await fs.mkdir(target3)
   await file.remove(target3)
   expect(await exists(target3)).toBe(false)
 
   // remove a dir recursive
   const target4 = path.join(temp, 'caz-remove-4')
-  await fs.promises.mkdir(target4 + '/subdir/foo/bar', { recursive: true })
+  await fs.mkdir(target4 + '/subdir/foo/bar', { recursive: true })
   await file.remove(target4)
   expect(await exists(target4)).toBe(false)
 
@@ -111,16 +111,16 @@ test('unit:core:file:write', async () => {
   const temp = await mktmpdir()
   const filename = path.join(temp, 'temp.txt')
   await file.write(filename, 'hello zce')
-  const contents = await fs.promises.readFile(filename, 'utf8')
+  const contents = await fs.readFile(filename, 'utf8')
   expect(contents).toBe('hello zce')
 
   await destory(temp)
 })
 
 test('unit:core:file:isBinary', async () => {
-  const buffer1 = await fs.promises.readFile(fixture('archive.zip'))
+  const buffer1 = await fs.readFile(fixture('archive.zip'))
   expect(file.isBinary(buffer1)).toBe(true)
-  const buffer2 = await fs.promises.readFile(fixture('.cazrc'))
+  const buffer2 = await fs.readFile(fixture('.cazrc'))
   expect(file.isBinary(buffer2)).toBe(false)
 })
 
@@ -190,14 +190,14 @@ test('unit:core:file:extract:zip', async () => {
 
   const file1 = path.join(dir, 'LICENSE')
   expect(await exists(file1)).toBe(true)
-  const stat1 = await fs.promises.stat(file1)
+  const stat1 = await fs.stat(file1)
   if (process.platform !== 'win32') {
     expect(stat1.mode & 0o777).toBe(0o644)
   }
 
   const file2 = path.join(dir, 'README.md')
   expect(await exists(file2)).toBe(true)
-  const stat2 = await fs.promises.stat(file2)
+  const stat2 = await fs.stat(file2)
   if (process.platform !== 'win32') {
     expect(stat2.mode & 0o777).toBe(0o755)
   }
diff --git a/src/core/file.ts b/src/core/file.ts
index cb23e181..5443b6c4 100644
--- a/src/core/file.ts
+++ b/src/core/file.ts
@@ -10,7 +10,7 @@ import AdmZip from 'adm-zip'
 export const exists = async (input: string): Promise<false | 'file' | 'dir' | 'other'> => {
   try {
     const stat = await fs.promises.stat(input)
-    /* istanbul ignore else */
+    /* c8 ignore next 5 */
     if (stat.isDirectory()) {
       return 'dir'
     } else if (stat.isFile()) {
@@ -19,7 +19,7 @@ export const exists = async (input: string): Promise<false | 'file' | 'dir' | 'o
       return 'other'
     }
   } catch (err) {
-    /* istanbul ignore if */
+    /* c8 ignore next */
     if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
       throw err
     }
@@ -156,7 +156,7 @@ export const extract = async (input: string, output: string, strip = 0): Promise
   // https://github.com/cthackers/adm-zip/issues/407#issuecomment-990086783
   // keep original file permissions
   zip.extractAllToAsync(output, true, true, err => {
-    /* istanbul ignore if */
+    /* c8 ignore next */
     if (err != null) throw err
     resolve()
   })
diff --git a/src/core/http.spec.ts b/src/core/http.spec.ts
index db57bd21..d3e335bc 100644
--- a/src/core/http.spec.ts
+++ b/src/core/http.spec.ts
@@ -1,6 +1,6 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import * as http from './http'
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { destory } from '../../test/helpers'
 
 const registry = 'https://registry.npmjs.org'
@@ -26,7 +26,7 @@ test('unit:core:http:request:error', async () => {
 
 test('unit:core:http:download', async () => {
   const filename = await http.download(tarball)
-  const stats = await fs.promises.stat(filename)
+  const stats = await fs.stat(filename)
   expect(stats.isFile()).toBe(true)
   expect(stats.size).toBe(367)
   await destory(filename)
@@ -34,7 +34,7 @@ test('unit:core:http:download', async () => {
 
 test('unit:core:http:download:text', async () => {
   const filename = await http.download(registry)
-  const stats = await fs.promises.stat(filename)
+  const stats = await fs.stat(filename)
   expect(stats.isFile()).toBe(true)
   await destory(filename)
 })
diff --git a/src/core/http.ts b/src/core/http.ts
index b2ee2f0f..8d86371c 100644
--- a/src/core/http.ts
+++ b/src/core/http.ts
@@ -14,7 +14,7 @@ const pipe = promisify(pipeline)
  * @param init init
  */
 export const request = async (url: RequestInfo, init: RequestInit = {}): Promise<Response> => {
-  /* istanbul ignore if */
+  /* c8 ignore next */
   if (config.proxy != null) {
     init.agent = new SocksProxyAgent(config.proxy)
   }
@@ -31,7 +31,7 @@ export const request = async (url: RequestInfo, init: RequestInit = {}): Promise
  */
 export const download = async (url: string): Promise<string> => {
   const response = await request(url)
-  /* istanbul ignore if */
+  /* c8 ignore next */
   if (response.body == null) throw Error('Unexpected response: Response body is empty')
   // ensure temp dirname
   await fs.mkdir(config.paths.temp, { recursive: true })
diff --git a/src/core/index.spec.ts b/src/core/index.spec.ts
index 28ee92e5..3658b4b9 100644
--- a/src/core/index.spec.ts
+++ b/src/core/index.spec.ts
@@ -1,4 +1,4 @@
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import * as core from '.'
 
 test('unit:core', async () => {
diff --git a/src/core/ware.spec.ts b/src/core/ware.spec.ts
index f7828a14..4cdcde4a 100644
--- a/src/core/ware.spec.ts
+++ b/src/core/ware.spec.ts
@@ -1,4 +1,4 @@
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { Ware } from './ware'
 
 test('unit:core:ware', async () => {
diff --git a/src/emit.spec.ts b/src/emit.spec.ts
index 111af8ad..d3bff29b 100644
--- a/src/emit.spec.ts
+++ b/src/emit.spec.ts
@@ -1,6 +1,6 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { jest, test, expect } from '@jest/globals'
+import { vi, test, expect } from 'vitest'
 import { context, destory, mktmpdir } from '../test/helpers'
 import emit from './emit'
 import { Context } from './types'
@@ -15,15 +15,15 @@ test('unit:emit:normal', async () => {
     ]
   })
   await emit(ctx)
-  const hello = await fs.promises.readFile(path.join(temp, 'hello.txt'), 'utf8')
+  const hello = await fs.readFile(path.join(temp, 'hello.txt'), 'utf8')
   expect(hello).toBe('hello')
-  const bar = await fs.promises.readFile(path.join(temp, 'foo/bar.txt'), 'utf8')
+  const bar = await fs.readFile(path.join(temp, 'foo/bar.txt'), 'utf8')
   expect(bar).toBe('bar')
   await destory(temp)
 })
 
 test('unit:emit:hook', async () => {
-  const callback = jest.fn<(ctx: Context) => Promise<void>>()
+  const callback = vi.fn<[ctx: Context], Promise<void>>()
   const ctx = context({}, { emit: callback })
   await emit(ctx)
   expect(callback.mock.calls[0][0]).toBe(ctx)
diff --git a/src/index.spec.ts b/src/index.spec.ts
index 9790a72c..3a4a6ba0 100644
--- a/src/index.spec.ts
+++ b/src/index.spec.ts
@@ -1,7 +1,7 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { jest, test, expect } from '@jest/globals'
-import { destory, exists, fixture, mktmpdir } from '../test/helpers'
+import { vi, test, expect } from 'vitest'
+import { destory, fixture, mktmpdir } from '../test/helpers'
 import { http } from './core'
 import * as caz from '.'
 
@@ -17,27 +17,25 @@ test('unit:exports', async () => {
 })
 
 test('unit:default', async () => {
-  const log = jest.spyOn(console, 'log')
-  const clear = jest.spyOn(console, 'clear')
+  const cwdtmpdir = await mktmpdir()
   const downloadtmpdir = await mktmpdir()
-  const download = jest.spyOn(http, 'download').mockImplementation(async () => {
+  const log = vi.spyOn(console, 'log')
+  const clear = vi.spyOn(console, 'clear')
+  const cwd = vi.spyOn(process, 'cwd').mockReturnValue(cwdtmpdir)
+  const download = vi.spyOn(http, 'download').mockImplementation(async () => {
     const file = fixture('minima.zip')
     const target = path.join(downloadtmpdir, 'minima.zip')
-    await fs.promises.copyFile(file, target)
+    await fs.copyFile(file, target)
     return target
   })
-  const temp = await mktmpdir()
-  const original = process.cwd()
-  process.chdir(temp)
   await caz.default('minima', 'minima-app', { force: true, offline: false, name: 'caz' })
-  expect(await exists('minima-app')).toBe(true)
-  const contents = await fs.promises.readFile('minima-app/caz.txt', 'utf8')
+  const contents = await fs.readFile(path.resolve('minima-app/caz.txt'), 'utf8')
   expect(contents.trim()).toBe('hey caz.')
-  process.chdir(original)
   log.mockRestore()
   clear.mockRestore()
+  cwd.mockRestore()
   download.mockRestore()
-  await destory(temp, downloadtmpdir)
+  await destory(cwdtmpdir, downloadtmpdir)
 })
 
 test('unit:error', async () => {
diff --git a/src/init.spec.ts b/src/init.spec.ts
index 58d874cc..fdb42b46 100644
--- a/src/init.spec.ts
+++ b/src/init.spec.ts
@@ -1,6 +1,6 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { context, destory, exists, mktmpdir } from '../test/helpers'
 import init from './init'
 
@@ -18,31 +18,31 @@ test('unit:init:false', async () => {
 
 test('unit:init:default', async () => {
   const temp = await mktmpdir()
-  await fs.promises.writeFile(path.join(temp, 'caz.txt'), 'hello')
+  await fs.writeFile(path.join(temp, 'caz.txt'), 'hello')
   const ctx = context({
     dest: temp,
     files: [{ path: '.gitignore', contents: Buffer.from('') }]
   })
   await init(ctx)
   expect(await exists(path.join(temp, '.git'))).toBe(true)
-  const stats = await fs.promises.stat(path.join(temp, '.git'))
+  const stats = await fs.stat(path.join(temp, '.git'))
   expect(stats.isDirectory()).toBe(true)
   expect(await exists(path.join(temp, '.git', 'COMMIT_EDITMSG'))).toBe(true)
-  const msg = await fs.promises.readFile(path.join(temp, '.git', 'COMMIT_EDITMSG'), 'utf8')
+  const msg = await fs.readFile(path.join(temp, '.git', 'COMMIT_EDITMSG'), 'utf8')
   expect(msg.trim()).toBe('feat: initial commit')
   await destory(temp)
 })
 
 test('unit:init:manual', async () => {
   const temp = await mktmpdir()
-  await fs.promises.writeFile(path.join(temp, 'caz.txt'), 'hello')
+  await fs.writeFile(path.join(temp, 'caz.txt'), 'hello')
   const ctx = context({ dest: temp }, { init: true })
   await init(ctx)
   expect(await exists(path.join(temp, '.git'))).toBe(true)
-  const stats = await fs.promises.stat(path.join(temp, '.git'))
+  const stats = await fs.stat(path.join(temp, '.git'))
   expect(stats.isDirectory()).toBe(true)
   expect(await exists(path.join(temp, '.git', 'COMMIT_EDITMSG'))).toBe(true)
-  const msg = await fs.promises.readFile(path.join(temp, '.git', 'COMMIT_EDITMSG'), 'utf8')
+  const msg = await fs.readFile(path.join(temp, '.git', 'COMMIT_EDITMSG'), 'utf8')
   expect(msg.trim()).toBe('feat: initial commit')
   await destory(temp)
 })
diff --git a/src/inquire.spec.ts b/src/inquire.spec.ts
index 3d1802e1..d120d06f 100644
--- a/src/inquire.spec.ts
+++ b/src/inquire.spec.ts
@@ -1,6 +1,6 @@
 import path from 'path'
 import prompts, { Answers, PromptObject } from 'prompts'
-import { jest, test, expect } from '@jest/globals'
+import { vi, test, expect } from 'vitest'
 import { context } from '../test/helpers'
 import { config } from './core'
 import inquire, { validater, processor } from './inquire'
@@ -48,7 +48,7 @@ test('unit:inquire:processor:name', async () => {
   expect(prompt2.validate).toBe(validater.name)
   expect(prompt2.initial).toBe('foo')
 
-  const validate3 = jest.fn<(prev: any, values: Answers<string>, prompt: PromptObject) => string>()
+  const validate3 = vi.fn<[prev: any, values: Answers<string>, prompt: PromptObject], string>()
   const prompt3: PromptObject = { name: 'name', type: 'text', validate: validate3 }
   fn(prompt3)
   expect(prompt3.validate).toBe(validate3)
@@ -63,23 +63,23 @@ test('unit:inquire:processor:version', async () => {
   expect(prompt0.validate).toBe(validater.version)
   expect(prompt0.initial).toBe('3.2.1')
 
-  const mockConfig = jest.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-version': '1.2.3' })
+  const mockConfig = vi.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-version': '1.2.3' })
 
   const prompt1: PromptObject = { name: 'version', type: 'text' }
   fn(prompt1)
   expect(prompt1.initial).toBe('1.2.3')
 
-  const validate2 = jest.fn<(prev: any, values: Answers<string>, prompt: PromptObject) => string>()
+  const validate2 = vi.fn<[prev: any, values: Answers<string>, prompt: PromptObject], string>()
   const prompt2: PromptObject = { name: 'version', type: 'text', validate: validate2 }
   fn(prompt2)
   expect(prompt2.validate).toBe(validate2)
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue({})
+  vi.spyOn(config, 'npm', 'get').mockReturnValue({})
   const prompt3: PromptObject = { name: 'version', type: 'text' }
   fn(prompt3)
   expect(prompt3.initial).toBe('0.1.0')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
   const prompt4: PromptObject = { name: 'version', type: 'text' }
   fn(prompt4)
   expect(prompt4.initial).toBe('0.1.0')
@@ -95,30 +95,30 @@ test('unit:inquire:processor:author', async () => {
   fn(prompt0)
   expect(prompt0.initial).toBe('zce')
 
-  const mockConfig = jest.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-author-name': 'faker-npm' })
+  const mockConfig = vi.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-author-name': 'faker-npm' })
 
   const prompt1: PromptObject = { name: 'author', type: 'text' }
   fn(prompt1)
   expect(prompt1.initial).toBe('faker-npm')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue({})
-  jest.spyOn(config, 'git', 'get').mockReturnValue({ user: { name: 'faker-git' } })
+  vi.spyOn(config, 'npm', 'get').mockReturnValue({})
+  vi.spyOn(config, 'git', 'get').mockReturnValue({ user: { name: 'faker-git' } })
   const prompt2: PromptObject = { name: 'author', type: 'text' }
   fn(prompt2)
   expect(prompt2.initial).toBe('faker-git')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
-  jest.spyOn(config, 'git', 'get').mockReturnValue({ user: { name: 'faker-git' } })
+  vi.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'git', 'get').mockReturnValue({ user: { name: 'faker-git' } })
   const prompt3: PromptObject = { name: 'author', type: 'text' }
   fn(prompt3)
   expect(prompt3.initial).toBe('faker-git')
 
-  jest.spyOn(config, 'git', 'get').mockReturnValue({})
+  vi.spyOn(config, 'git', 'get').mockReturnValue({})
   const prompt4: PromptObject = { name: 'author', type: 'text' }
   fn(prompt4)
   expect(prompt4.initial).toBe(undefined)
 
-  jest.spyOn(config, 'git', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'git', 'get').mockReturnValue(undefined)
   const prompt5: PromptObject = { name: 'author', type: 'text' }
   fn(prompt5)
   expect(prompt5.initial).toBe(undefined)
@@ -134,36 +134,36 @@ test('unit:inquire:processor:email', async () => {
   fn(prompt0)
   expect(prompt0.initial).toBe('w@zce.me')
 
-  const mockConfig = jest.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-author-email': 'npm@faker.com' })
+  const mockConfig = vi.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-author-email': 'npm@faker.com' })
 
   const prompt1: PromptObject = { name: 'email', type: 'text' }
   fn(prompt1)
   expect(prompt1.validate).toBe(validater.email)
   expect(prompt1.initial).toBe('npm@faker.com')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue({})
-  jest.spyOn(config, 'git', 'get').mockReturnValue({ user: { email: 'git@faker.com' } })
+  vi.spyOn(config, 'npm', 'get').mockReturnValue({})
+  vi.spyOn(config, 'git', 'get').mockReturnValue({ user: { email: 'git@faker.com' } })
   const prompt2: PromptObject = { name: 'email', type: 'text' }
   fn(prompt2)
   expect(prompt2.initial).toBe('git@faker.com')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
-  jest.spyOn(config, 'git', 'get').mockReturnValue({ user: { email: 'git@faker.com' } })
+  vi.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'git', 'get').mockReturnValue({ user: { email: 'git@faker.com' } })
   const prompt3: PromptObject = { name: 'email', type: 'text' }
   fn(prompt3)
   expect(prompt3.initial).toBe('git@faker.com')
 
-  jest.spyOn(config, 'git', 'get').mockReturnValue({})
+  vi.spyOn(config, 'git', 'get').mockReturnValue({})
   const prompt4: PromptObject = { name: 'email', type: 'text' }
   fn(prompt4)
   expect(prompt4.initial).toBe(undefined)
 
-  jest.spyOn(config, 'git', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'git', 'get').mockReturnValue(undefined)
   const prompt5: PromptObject = { name: 'email', type: 'text' }
   fn(prompt5)
   expect(prompt5.initial).toBe(undefined)
 
-  const validate6 = jest.fn<(prev: any, values: Answers<string>, prompt: PromptObject) => string>()
+  const validate6 = vi.fn<[prev: any, values: Answers<string>, prompt: PromptObject], string>()
   const prompt6: PromptObject = { name: 'email', type: 'text', validate: validate6 }
   fn(prompt6)
   expect(prompt6.validate).toBe(validate6)
@@ -179,36 +179,36 @@ test('unit:inquire:processor:url', async () => {
   fn(prompt0)
   expect(prompt0.initial).toBe('https://zce.me')
 
-  const mockConfig = jest.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-author-url': 'https://npm.faker.com' })
+  const mockConfig = vi.spyOn(config, 'npm', 'get').mockReturnValue({ 'init-author-url': 'https://npm.faker.com' })
 
   const prompt1: PromptObject = { name: 'url', type: 'text' }
   fn(prompt1)
   expect(prompt1.validate).toBe(validater.url)
   expect(prompt1.initial).toBe('https://npm.faker.com')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue({})
-  jest.spyOn(config, 'git', 'get').mockReturnValue({ user: { url: 'https://git.faker.com' } })
+  vi.spyOn(config, 'npm', 'get').mockReturnValue({})
+  vi.spyOn(config, 'git', 'get').mockReturnValue({ user: { url: 'https://git.faker.com' } })
   const prompt2: PromptObject = { name: 'url', type: 'text' }
   fn(prompt2)
   expect(prompt2.initial).toBe('https://git.faker.com')
 
-  jest.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
-  jest.spyOn(config, 'git', 'get').mockReturnValue({ user: { url: 'https://git.faker.com' } })
+  vi.spyOn(config, 'npm', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'git', 'get').mockReturnValue({ user: { url: 'https://git.faker.com' } })
   const prompt3: PromptObject = { name: 'url', type: 'text' }
   fn(prompt3)
   expect(prompt3.initial).toBe('https://git.faker.com')
 
-  jest.spyOn(config, 'git', 'get').mockReturnValue({})
+  vi.spyOn(config, 'git', 'get').mockReturnValue({})
   const prompt4: PromptObject = { name: 'url', type: 'text' }
   fn(prompt4)
   expect(prompt4.initial).toBe(undefined)
 
-  jest.spyOn(config, 'git', 'get').mockReturnValue(undefined)
+  vi.spyOn(config, 'git', 'get').mockReturnValue(undefined)
   const prompt5: PromptObject = { name: 'url', type: 'text' }
   fn(prompt5)
   expect(prompt5.initial).toBe(undefined)
 
-  const validate6 = jest.fn<(prev: any, values: Answers<string>, prompt: PromptObject) => string>()
+  const validate6 = vi.fn<[prev: any, values: Answers<string>, prompt: PromptObject], string>()
   const prompt6: PromptObject = { name: 'url', type: 'text', validate: validate6 }
   fn(prompt6)
   expect(prompt6.validate).toBe(validate6)
@@ -217,7 +217,7 @@ test('unit:inquire:processor:url', async () => {
 })
 
 test('unit:inquire:default', async () => {
-  const clear = jest.spyOn(console, 'clear')
+  const clear = vi.spyOn(console, 'clear')
   const ctx = context({ dest: __dirname })
   prompts.inject(['foo'])
   await inquire(ctx)
@@ -228,7 +228,7 @@ test('unit:inquire:default', async () => {
 })
 
 test('unit:inquire:custom', async () => {
-  const clear = jest.spyOn(console, 'clear')
+  const clear = vi.spyOn(console, 'clear')
   const ctx = context({}, {
     prompts: [
       { name: 'foo', type: 'text', message: 'foo' },
@@ -243,7 +243,7 @@ test('unit:inquire:custom', async () => {
 })
 
 test('unit:inquire:override', async () => {
-  const clear = jest.spyOn(console, 'clear')
+  const clear = vi.spyOn(console, 'clear')
   const ctx = context({}, {
     prompts: [
       { name: 'foo', type: 'text', message: 'foo' },
diff --git a/src/inquire.ts b/src/inquire.ts
index d84e558b..9ba1b898 100644
--- a/src/inquire.ts
+++ b/src/inquire.ts
@@ -12,7 +12,7 @@ export const validater: Record<string, (input: string) => true | string> = {
   name: input => {
     const result = validateName(input)
     if (result.validForNewPackages) return true
-    /* istanbul ignore next */
+    /* c8 ignore next */
     return result.errors?.join(', ') ?? result.warnings?.join(',') ?? ''
   },
   version: input => {
@@ -79,7 +79,7 @@ export default async (ctx: Context): Promise<void> => {
   // override by options (cli argv)
   prompts.override(ctx.options)
 
-  /* istanbul ignore next */
+  /* c8 ignore next */
   const onCancel = (): never => {
     throw new Error('You have cancelled this task.')
   }
diff --git a/src/install.spec.ts b/src/install.spec.ts
index 35581fbf..a0f19807 100644
--- a/src/install.spec.ts
+++ b/src/install.spec.ts
@@ -1,6 +1,6 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { context, destory, exists, mktmpdir } from '../test/helpers'
 import install from './install'
 
@@ -19,7 +19,7 @@ test('unit:install:null', async () => {
 test('unit:install:default', async () => {
   const temp = await mktmpdir()
   const pkg = { dependencies: { caz: '0.0.0' } }
-  await fs.promises.writeFile(path.join(temp, 'package.json'), JSON.stringify(pkg))
+  await fs.writeFile(path.join(temp, 'package.json'), JSON.stringify(pkg))
   const ctx = context({
     dest: temp,
     files: [{ path: 'package.json', contents: Buffer.from('') }]
@@ -33,10 +33,10 @@ test('unit:install:default', async () => {
 })
 
 // required yarn env
-test('unit:install:manual:yarn', async () => {
+test('unit:install:yarn', async () => {
   const temp = await mktmpdir()
   const pkg = { dependencies: { caz: '0.0.0' } }
-  await fs.promises.writeFile(path.join(temp, 'package.json'), JSON.stringify(pkg))
+  await fs.writeFile(path.join(temp, 'package.json'), JSON.stringify(pkg))
   const ctx = context({ dest: temp }, { install: 'yarn' })
   await install(ctx)
   expect(await exists(path.join(temp, 'yarn.lock'))).toBe(true)
@@ -47,10 +47,10 @@ test('unit:install:manual:yarn', async () => {
 })
 
 // required pnpm env
-test('unit:install:manual:pnpm', async () => {
+test('unit:install:pnpm', async () => {
   const temp = await mktmpdir()
   const pkg = { dependencies: { caz: '0.0.0' } }
-  await fs.promises.writeFile(path.join(temp, 'package.json'), JSON.stringify(pkg))
+  await fs.writeFile(path.join(temp, 'package.json'), JSON.stringify(pkg))
   const ctx = context({ dest: temp }, { install: 'pnpm' })
   await install(ctx)
   expect(await exists(path.join(temp, 'pnpm-lock.yaml'))).toBe(true)
@@ -60,9 +60,9 @@ test('unit:install:manual:pnpm', async () => {
   await destory(temp)
 })
 
-test('unit:install:manual:error', async () => {
+test('unit:install:error', async () => {
   const temp = await mktmpdir()
-  await fs.promises.writeFile(path.join(temp, 'package.json'), 'error package.json')
+  await fs.writeFile(path.join(temp, 'package.json'), 'error package.json')
   const ctx = context({ dest: temp }, { install: 'npm' })
   expect.hasAssertions()
   try {
diff --git a/src/install.ts b/src/install.ts
index 0d3bdf30..a98c59fd 100644
--- a/src/install.ts
+++ b/src/install.ts
@@ -18,7 +18,7 @@ export default async (ctx: Context): Promise<void> => {
 
   try {
     const client = ctx.config.install
-    /* istanbul ignore next */
+    /* c8 ignore next */
     const cmd = process.platform === 'win32' ? client + '.cmd' : client
     await exec(cmd, ['install'], { cwd: ctx.dest, stdio: 'inherit' })
   } catch (e) {
diff --git a/src/list/fetch.spec.ts b/src/list/fetch.spec.ts
index 124f530a..d96dea26 100644
--- a/src/list/fetch.spec.ts
+++ b/src/list/fetch.spec.ts
@@ -1,4 +1,4 @@
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import fetch from './fetch'
 
 test('unit:fetch:empty', async () => {
diff --git a/src/list/index.spec.ts b/src/list/index.spec.ts
index 8cc55fae..7596bb91 100644
--- a/src/list/index.spec.ts
+++ b/src/list/index.spec.ts
@@ -1,43 +1,43 @@
-import { jest, test, expect } from '@jest/globals'
+import { vi, test, expect } from 'vitest'
 import list from '.'
 
 test('unit:list:default', async () => {
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await list()
   expect(log.mock.calls[0][0]).toBe('Available official\'s templates:')
   log.mockRestore()
 })
 
 test('unit:list:owner', async () => {
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await list('zce')
   expect(log.mock.calls[0][0]).toBe('Available zce\'s templates:')
   log.mockRestore()
 })
 
 test('unit:list:json', async () => {
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await list(undefined, { json: true })
   expect(log.mock.calls[0][0]).toMatch(/^\[.+\]$/)
   log.mockRestore()
 })
 
 test('unit:list:short', async () => {
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await list(undefined, { short: true })
   expect(log.mock.calls[0][0]).toMatch(/^→\s.+$/)
   log.mockRestore()
 })
 
 test('unit:list:short-owner', async () => {
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await list('zce', { short: true })
   expect(log.mock.calls[0][0]).toMatch(/^→\s.+$/)
   log.mockRestore()
 })
 
 test('unit:list:empty', async () => {
-  const log = jest.spyOn(console, 'log')
+  const log = vi.spyOn(console, 'log')
   await list('ghost')
   expect(log.mock.calls[0][0]).toBe('No available templates.')
   log.mockRestore()
diff --git a/src/load.spec.ts b/src/load.spec.ts
index 914d2705..6094d506 100644
--- a/src/load.spec.ts
+++ b/src/load.spec.ts
@@ -1,6 +1,6 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { context, destory, exists, fixture, mktmpdir } from '../test/helpers'
 import load from './load'
 
@@ -41,7 +41,7 @@ test('unit:load:error', async () => {
 test('unit:load:install-deps', async () => {
   const temp = await mktmpdir()
 
-  await fs.promises.writeFile(path.join(temp, 'package.json'), JSON.stringify({
+  await fs.writeFile(path.join(temp, 'package.json'), JSON.stringify({
     dependencies: { caz: '0.0.0' },
     devDependencies: { zce: '0.0.0' }
   }))
diff --git a/src/load.ts b/src/load.ts
index 0a43cc91..7621e84c 100644
--- a/src/load.ts
+++ b/src/load.ts
@@ -17,7 +17,7 @@ export default async (ctx: Context): Promise<void> => {
   // Automatic install template dependencies.
   const spinner = ora('Installing template dependencies...').start()
   try {
-    /* istanbul ignore next */
+    /* c8 ignore next */
     const cmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
     await exec(cmd, ['install', '--production'], { cwd: ctx.src })
     spinner.succeed('Installing template dependencies complete.')
diff --git a/src/prepare.spec.ts b/src/prepare.spec.ts
index 7b8f01cc..24762940 100644
--- a/src/prepare.spec.ts
+++ b/src/prepare.spec.ts
@@ -1,4 +1,4 @@
-import { jest, test, expect } from '@jest/globals'
+import { vi, test, expect } from 'vitest'
 import { context, fixture } from '../test/helpers'
 import prepare from './prepare'
 import { Context } from './types'
@@ -42,7 +42,7 @@ test('unit:prepare:custom', async () => {
 })
 
 test('unit:prepare:hook', async () => {
-  const callback = jest.fn<(ctx: Context) => Promise<void>>()
+  const callback = vi.fn<(ctx: Context) => Promise<void>>()
   const ctx = context({}, { prepare: callback })
   await prepare(ctx)
   expect(callback.mock.calls[0][0]).toBe(ctx)
diff --git a/src/rename.spec.ts b/src/rename.spec.ts
index fd026dc6..be137107 100644
--- a/src/rename.spec.ts
+++ b/src/rename.spec.ts
@@ -1,4 +1,4 @@
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { context } from '../test/helpers'
 import rename from './rename'
 
diff --git a/src/render.spec.ts b/src/render.spec.ts
index 871885b6..86abc842 100644
--- a/src/render.spec.ts
+++ b/src/render.spec.ts
@@ -1,5 +1,5 @@
 import fs from 'fs'
-import { test, expect } from '@jest/globals'
+import { test, expect } from 'vitest'
 import { context, fixture } from '../test/helpers'
 import render from './render'
 
diff --git a/src/resolve.spec.ts b/src/resolve.spec.ts
index 278a3e14..c0740f03 100644
--- a/src/resolve.spec.ts
+++ b/src/resolve.spec.ts
@@ -1,24 +1,23 @@
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
-import { SpyInstance } from 'jest-mock'
-import { jest, test, expect, beforeEach, afterEach } from '@jest/globals'
+import { vi, test, expect, beforeEach, afterEach, SpyInstance } from 'vitest'
 import { context, exists, destory, fixture, mktmpdir } from '../test/helpers'
 import { file, http, config } from './core'
 import resolve, { getTemplatePath, getTemplateUrl } from './resolve'
 
-let log: SpyInstance<(message?: any, ...optionalParams: any[]) => void>
-let download: SpyInstance<(url: string) => Promise<string>>
+let log: SpyInstance<[message?: any, ...optionalParams: any[]], void>
+let download: SpyInstance<[url: string], Promise<string>>
 let tmpdir: string | undefined
 
 const src = path.join(config.paths.cache, 'f8327697301af2fa')
 
 beforeEach(async () => {
-  log = jest.spyOn(console, 'log')
-  download = jest.spyOn(http, 'download').mockImplementation(async () => {
+  log = vi.spyOn(console, 'log')
+  download = vi.spyOn(http, 'download').mockImplementation(async () => {
     tmpdir = await mktmpdir()
     const file = fixture('archive.zip')
     const target = path.join(tmpdir, 'archive.zip')
-    await fs.promises.copyFile(file, target)
+    await fs.copyFile(file, target)
     return target
   })
 })
@@ -100,7 +99,7 @@ test('unit:resolve:local-tildify', async () => {
 })
 
 test('unit:resolve:fetch-remote', async () => {
-  await fs.promises.mkdir(src, { recursive: true })
+  await fs.mkdir(src, { recursive: true })
 
   const ctx = context({ template: 'minima' })
   await resolve(ctx)
@@ -111,7 +110,7 @@ test('unit:resolve:fetch-remote', async () => {
 })
 
 test('unit:resolve:fetch-cache-success', async () => {
-  await fs.promises.mkdir(src, { recursive: true })
+  await fs.mkdir(src, { recursive: true })
 
   const ctx = context({ template: 'minima', options: { offline: true } })
   await resolve(ctx)
diff --git a/src/setup.spec.ts b/src/setup.spec.ts
index e54ce2c7..13a19333 100644
--- a/src/setup.spec.ts
+++ b/src/setup.spec.ts
@@ -1,4 +1,4 @@
-import { jest, test, expect } from '@jest/globals'
+import { vi, test, expect } from 'vitest'
 import { context } from '../test/helpers'
 import setup from './setup'
 import { Context } from './types'
@@ -10,7 +10,7 @@ test('unit:setup:null', async () => {
 })
 
 test('unit:setup:callback', async () => {
-  const callback = jest.fn<(ctx: Context) => Promise<void>>()
+  const callback = vi.fn<[ctx: Context], Promise<void>>()
   const ctx = context({}, { setup: callback })
   await setup(ctx)
   expect(callback.mock.calls[0][0]).toBe(ctx)
diff --git a/test/helpers.ts b/test/helpers.ts
index 1752f189..ff0d1e49 100644
--- a/test/helpers.ts
+++ b/test/helpers.ts
@@ -1,5 +1,5 @@
 import os from 'os'
-import fs from 'fs'
+import fs from 'fs/promises'
 import path from 'path'
 import { Context, Template } from '../src'
 
@@ -18,7 +18,7 @@ export const fixture = (target: string): string => {
  * @returns true if input is exists
  */
 export const exists = async (input: string): Promise<boolean> => {
-  return await fs.promises.access(input).then(() => true).catch(() => false)
+  return await fs.access(input).then(() => true).catch(() => false)
 }
 
 /**
@@ -26,7 +26,7 @@ export const exists = async (input: string): Promise<boolean> => {
  * @returns temp directory path
  */
 export const mktmpdir = async (): Promise<string> => {
-  return await fs.promises.mkdtemp(path.join(os.tmpdir(), 'caz-test-'))
+  return await fs.mkdtemp(path.join(os.tmpdir(), 'caz-test-'))
 }
 
 /**
@@ -36,7 +36,7 @@ export const mktmpdir = async (): Promise<string> => {
 export const destory = async (...target: string[]): Promise<void> => {
   for (const item of target) {
     // cleanup require node >= v14.14.0
-    await fs.promises.rm(item, { recursive: true, force: true })
+    await fs.rm(item, { recursive: true, force: true })
   }
 }
 
@@ -47,7 +47,7 @@ export const destory = async (...target: string[]): Promise<void> => {
 // export const download = async () => {
 //   const file = fixture('archive.zip')
 //   const target = path.join(await mktmpdir(), 'archive.zip')
-//   await fs.promises.copyFile(file, target)
+//   await fs.copyFile(file, target)
 //   return target
 // }