test: setup tests for the CLI

bin/dev.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env bun
-// #!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
 
 // eslint-disable-next-line n/shebang
 import { execute } from '@oclif/core'

bin/run.js

@@ -2,5 +2,4 @@
 
 import { execute } from '@oclif/core'
 
-console.log('Running the CLI:', import.meta.url)
 await execute({ dir: import.meta.url })

package.json

@@ -8,7 +8,7 @@
     "build": "tsup",
     "watch": "tsup --watch",
     "clean": "rm -rf dist docs",
-    "test": "jest",
+    "test": "vitest --globals",
     "docs": "typedoc",
     "format": "prettier --write .",
     "format:check": "prettier --check ."
@@ -39,7 +39,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "repository": {
     "type": "git",
@@ -69,16 +70,17 @@
     "yaml": "^2.4.5"
   },
   "devDependencies": {
+    "@oclif/test": "^4.0.9",
     "@types/jest": "^29.2.5",
     "docdash": "^2.0.1",
-    "jest": "^29.4.1",
     "prettier": "^3.0.0",
     "ts-jest": "^29.0.4",
     "ts-node": "^10.9.2",
     "tsup": "^8.0.2",
     "typedoc": "^0.24.8",
     "typedoc-plugin-export-functions": "^1.0.0",
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.4",
+    "vitest": "^2.1.1"
   },
   "tsup": {
     "entry": [

test/cli-utils.ts

@@ -0,0 +1,98 @@
+import {
+  ExecException,
+  execSync,
+  ExecSyncOptionsWithBufferEncoding,
+} from 'child_process'
+import path, { join } from 'path'
+import fs, { mkdtempSync } from 'fs'
+import os from 'os'
+
+export type ExecError = ExecException & { stderr: string; stdout: string }
+
+export type ExecOptions = ExecSyncOptionsWithBufferEncoding & {
+  silent?: boolean
+}
+
+export type ExecResult = {
+  code: number
+  stdout?: string
+  stderr?: string
+  error?: ExecError
+}
+
+const TEST_DATA_DIR = path.join(process.cwd(), 'test', 'commands-data')
+
+/**
+ * Utility test class to execute the CLI command
+ */
+export class CLIExecutor {
+  private binPath: string
+
+  constructor() {
+    const curentDir = process.cwd()
+    this.binPath =
+      process.platform === 'win32'
+        ? path.join(curentDir, 'bin', 'dev.cmd')
+        : path.join(curentDir, 'bin', 'dev.js')
+  }
+
+  public execCommand(cmd: string, options?: ExecOptions): Promise<ExecResult> {
+    const silent = options?.silent ?? true
+    const command = `${this.binPath} ${cmd}`
+    const cwd = process.cwd()
+
+    return new Promise((resolve) => {
+      if (silent) {
+        try {
+          const r = execSync(command, { ...options, stdio: 'pipe', cwd })
+          const stdout = r.toString()
+
+          resolve({ code: 0, stdout })
+        } catch (error) {
+          const err = error as ExecError
+          console.log(error)
+
+          resolve({
+            code: 1,
+            error: err,
+            stdout: err.stdout?.toString() ?? '',
+            stderr: err.stderr?.toString() ?? '',
+          })
+        }
+      } else {
+        execSync(command, { ...options, stdio: 'inherit', cwd })
+        resolve({ code: 0 })
+      }
+    })
+  }
+}
+
+// On macOS, os.tmpdir() is not a real path:
+// https://github.com/nodejs/node/issues/11422
+const TMP_DIR = fs.realpathSync(os.tmpdir())
+
+export async function runInDir(
+  dir: 'tmp' | string,
+  fn: () => Promise<void>,
+): Promise<void> {
+  const baseCwd = process.cwd()
+  const ctd =
+    dir === 'tmp'
+      ? mkdtempSync(path.join(TMP_DIR, 'publicodes-cli-test-'))
+      : path.join(TEST_DATA_DIR, dir)
+
+  if (!fs.existsSync(ctd)) {
+    fs.mkdirSync(ctd, { recursive: true })
+  }
+
+  process.chdir(ctd)
+
+  try {
+    await fn()
+  } finally {
+    process.chdir(baseCwd)
+    if (dir === 'tmp' && fs.existsSync(ctd)) {
+      fs.rmSync(ctd, { recursive: true })
+    }
+  }
+}

test/commands-data/yarn-init/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "yarn-init",
+  "version": "1.0.0",
+  "description": "",
+  "author": "",
+  "type": "module",
+  "main": "index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "publicodes": "^1.5.1"
+  }
+}

test/commands/base.test.ts

@@ -0,0 +1,13 @@
+import { CLIExecutor, runInDir } from '../cli-utils'
+
+describe('publicodes --help', () => {
+  it('should list all available commands', async () => {
+    const cli = new CLIExecutor()
+
+    runInDir('tmp', async () => {
+      const { stdout } = await cli.execCommand('--help')
+
+      expect(stdout).toContain('init  initialize a new project')
+    })
+  })
+})

test/commands/init.test.ts

@@ -0,0 +1,31 @@
+import { execSync } from 'child_process'
+import { CLIExecutor, runInDir } from '../cli-utils'
+import fs from 'fs'
+
+describe('publicodes init', () => {
+  it('should update existing package.json', async () => {
+    const cli = new CLIExecutor()
+
+    runInDir('tmp', async () => {
+      execSync('yarn init -y')
+      const { stdout } = await cli.execCommand('init')
+
+      expect(stdout).toContain('existing package.json file')
+      expect(stdout).toContain('package.json file written')
+      expect(stdout).toContain('🚀 publicodes is ready to use!')
+      const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
+      expect(packageJson).toMatchObject({
+        type: 'module',
+        main: 'dist/index.js',
+        types: 'dist/index.d.ts',
+        files: ['dist'],
+        peerDependencies: {
+          publicodes: '^1.5.1',
+        },
+        devDependencies: {
+          '@publicodes/tools': '^1.5.1',
+        },
+      })
+    })
+  })
+})

test/optims/constantFolding.test.ts

@@ -2,7 +2,7 @@ import Engine, { RuleNode } from 'publicodes'
 import { serializeParsedRules } from '../../src'
 import { RuleName, RawRules, disabledLogger } from '../../src/commons'
 import { constantFolding } from '../../src/optims/'
-import { callWithEngine } from '../utils.test'
+import { callWithEngine } from '../utils'
 
 function constantFoldingWith(rawRules: any, targets?: RuleName[]): RawRules {
   const res = callWithEngine(

test/utils.test.ts → test/utils.ts

@@ -1,6 +1,9 @@
 import { RuleName, disabledLogger } from '../src/commons'
 import Engine from 'publicodes'
 import type { ParsedRules } from 'publicodes'
+import { ChildProcess, exec } from 'child_process'
+import fs from 'fs'
+import path from 'path'
 
 export function callWithEngine<R>(fn: (engine: Engine) => R, rawRules: any): R {
   const engine = new Engine(rawRules, {

tsconfig.json

@@ -9,7 +9,7 @@
     "resolveJsonModule": true,
     "allowJs": true,
     "sourceMap": true,
-    "types": ["jest", "node"],
+    "types": ["vitest/globals", "node"],
     "declaration": true,
     "forceConsistentCasingInFileNames": true,
     "allowSyntheticDefaultImports": true