chore(cli): add unit tests

Author: hugoabernier

dist/cli.js

@@ -11,16 +11,13 @@
     "README.md",
     "LICENSE"
   ],
-
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
-
   "engines": {
     "node": ">=20"
   },
-
   "scripts": {
     "build": "tsup src/cli.ts --format esm --target node18 --sourcemap --clean",
     "test": "npm run build && NODE_ENV=test node --test",
@@ -46,15 +43,16 @@
     "progress": "^2.0.3"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "semantic-release": "^24.0.0",
-    "@semantic-release/commit-analyzer": "^13.0.0",
-    "@semantic-release/release-notes-generator": "^14.0.0",
     "@semantic-release/changelog": "^6.0.0",
-    "@semantic-release/npm": "^12.0.0",
+    "@semantic-release/commit-analyzer": "^13.0.0",
+    "@semantic-release/git": "^10.0.0",
     "@semantic-release/github": "^11.0.0",
-    "@semantic-release/git": "^10.0.0"
+    "@semantic-release/npm": "^12.0.0",
+    "@semantic-release/release-notes-generator": "^14.0.0",
+    "@types/node": "^25.0.3",
+    "@types/progress": "^2.0.7",
+    "semantic-release": "^24.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
   }
-}
+}

dist/cli.js.map

@@ -39,6 +39,7 @@ function normalizeSampleArg(sample: string): string {
     if (s.startsWith("samples/")) return s.slice("samples/".length);
     return s;
 }
+export { normalizeSampleArg };
 
 async function pathExists(p: string): Promise<boolean> {
     try {
@@ -115,6 +116,7 @@ function parseGitVersion(output: string): { major: number; minor: number; patch:
     if (!m) return null;
     return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]) };
 }
+export { parseGitVersion };
 
 function versionGte(
     v: { major: number; minor: number; patch: number },
@@ -124,6 +126,7 @@ function versionGte(
     if (v.minor !== min.minor) return v.minor > min.minor;
     return v.patch >= min.patch;
 }
+export { versionGte };
 
 async function ensureGit(verbose?: boolean): Promise<void> {
     let res: RunResult;
@@ -161,6 +164,7 @@ function assertMethod(m: string | undefined): Method {
     if (m === "auto" || m === "git" || m === "api") return m;
     throw new Error(`Invalid --method "${m}". Use "auto", "git", or "api".`);
 }
+export { assertMethod };
 
 async function copyDir(src: string, dest: string): Promise<void> {
     await fs.mkdir(dest, { recursive: true });
@@ -384,11 +388,13 @@ function assertMode(m: string | undefined): Mode {
     if (m === "extract" || m === "repo") return m;
     throw new Error(`Invalid --mode "${m}". Use "extract" or "repo".`);
 }
+export { assertMode };
 
 function isGuid(v: string): boolean {
     // Accepts RFC4122-ish GUIDs (case-insensitive)
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(v);
 }
+export { isGuid };
 
 async function readJsonIfExists<T>(filePath: string): Promise<T | null> {
     try {
@@ -732,6 +738,94 @@ program
         }
     });
 
+/**
+ * Testable handler for the `get` command. Allows injecting dependencies for unit testing.
+ */
+export async function getCommandHandler(sample: string, options: CliOptions, deps?: {
+    download?: typeof downloadSampleViaGitHubSubtree;
+    fetchSparse?: typeof fetchSampleViaSparseGitExtract;
+    sparseClone?: typeof sparseCloneInto;
+    postProcess?: typeof postProcessProject;
+    finalize?: typeof finalizeExtraction;
+    isGitAvailable?: typeof isGitAvailable;
+    ensureGit?: typeof ensureGit;
+}) {
+    const sampleFolder = normalizeSampleArg(sample);
+    const ref = options.ref || DEFAULT_REF;
+    const repo = options.repo || DEFAULT_REPO;
+    const owner = options.owner || DEFAULT_OWNER;
+    const verbose = !!options.verbose;
+
+    const download = deps?.download ?? downloadSampleViaGitHubSubtree;
+    const fetchSparse = deps?.fetchSparse ?? fetchSampleViaSparseGitExtract;
+    const sparseClone = deps?.sparseClone ?? sparseCloneInto;
+    const postProcess = deps?.postProcess ?? postProcessProject;
+    const finalize = deps?.finalize ?? finalizeExtraction;
+    const gitAvailableFn = deps?.isGitAvailable ?? isGitAvailable;
+    const ensureGitFn = deps?.ensureGit ?? ensureGit;
+
+    let mode: Mode;
+    try {
+        mode = assertMode(options.mode);
+    } catch (e) {
+        throw e;
+    }
+
+    let method: Method;
+    try {
+        method = assertMethod(options.method);
+    } catch (e) {
+        throw e;
+    }
+
+    const defaultDest = mode === "extract" ? `./${sampleFolder}` : `./${repo}-${sampleFolder}`.replaceAll("/", "-");
+    const destDir = path.resolve(options.dest ?? defaultDest);
+
+    const gitAvailable = await gitAvailableFn(verbose);
+    const chosen: Method = method === "auto" ? (gitAvailable ? "git" : "api") : method;
+
+    if (chosen === "git") {
+        await ensureGitFn(verbose);
+    }
+
+    if (chosen === "api" && mode === "repo") {
+        throw new Error(`--mode repo requires --method git (API method cannot create a git working repo).`);
+    }
+
+    if (await pathExists(destDir)) {
+        if (!options.force) {
+            const nonEmpty = await isDirNonEmpty(destDir);
+            if (nonEmpty) throw new Error(`Destination exists and is not empty: ${destDir}`);
+        } else {
+            await fs.rm(destDir, { recursive: true, force: true });
+        }
+    }
+
+    if (chosen === "api") {
+        await fs.mkdir(destDir, { recursive: true });
+        await download({ owner, repo, ref, sampleFolder, destDir, concurrency: 8, verbose, signal: undefined, onProgress: undefined });
+        await postProcess(destDir, options, undefined);
+        await finalize({ spinner: undefined, successMessage: `Done`, projectPath: destDir });
+        return;
+    }
+
+    if (chosen === "git") {
+        if (mode === "extract") {
+            await fetchSparse({ owner, repo, ref, sampleFolder, destDir, verbose, spinner: undefined, signal: undefined });
+            await postProcess(destDir, options, undefined);
+            await finalize({ spinner: undefined, successMessage: `Done`, projectPath: destDir });
+            return;
+        } else {
+            await fs.mkdir(destDir, { recursive: true });
+            await sparseClone({ owner, repo, ref, sampleFolder, repoDir: destDir, verbose, spinner: undefined, signal: undefined });
+            const samplePath = path.join(destDir, "samples", sampleFolder);
+            await postProcess(samplePath, options, undefined);
+            await finalize({ spinner: undefined, successMessage: `Done`, projectPath: samplePath, repoRoot: destDir });
+            return;
+        }
+    }
+}
+
 program
     .command("rename")
     .argument("<path>", "Path to previously downloaded sample folder (project root)")

package-lock.json

@@ -0,0 +1,69 @@
+import test from 'node:test';
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { getCommandHandler } from '../dist/cli.js';
+
+async function mkTmpDir() {
+  return await fs.mkdtemp(path.join(os.tmpdir(), 'spfx-get-'));
+}
+
+test('getCommandHandler uses API download when git unavailable', async () => {
+  const tmp = await mkTmpDir();
+  let downloaded = false;
+  const fakeDownload = async (opts) => {
+    downloaded = true;
+    // create a package.json to simulate download
+    await fs.writeFile(path.join(opts.destDir, 'package.json'), JSON.stringify({ name: 'downloaded' }, null, 2));
+  };
+  await getCommandHandler('react-hello-world', { method: 'auto', mode: 'extract', dest: tmp }, {
+    download: fakeDownload,
+    isGitAvailable: async () => false,
+    ensureGit: async () => {},
+    postProcess: async () => {},
+    finalize: async () => {}
+  });
+
+  assert.ok(downloaded);
+  const pkg = JSON.parse(await fs.readFile(path.join(tmp, 'package.json'), 'utf8'));
+  assert.equal(pkg.name, 'downloaded');
+});
+
+test('getCommandHandler throws when dest exists and not force', async () => {
+  const tmp = await mkTmpDir();
+  await fs.writeFile(path.join(tmp, 'existing.txt'), 'x');
+  let threw = false;
+  try {
+    await getCommandHandler('react-hello-world', { method: 'api', mode: 'extract', dest: tmp }, {
+      download: async () => {},
+      isGitAvailable: async () => false,
+      ensureGit: async () => {},
+      postProcess: async () => {},
+      finalize: async () => {}
+    });
+  } catch (e) {
+    threw = true;
+  }
+  assert.ok(threw);
+});
+
+test('getCommandHandler accepts --force and overwrites', async () => {
+  const tmp = await mkTmpDir();
+  await fs.writeFile(path.join(tmp, 'existing.txt'), 'x');
+  let downloaded = false;
+  const fakeDownload = async (opts) => {
+    downloaded = true;
+    await fs.writeFile(path.join(opts.destDir, 'package.json'), JSON.stringify({ name: 'forced' }, null, 2));
+  };
+  await getCommandHandler('react-hello-world', { method: 'api', mode: 'extract', dest: tmp, force: true }, {
+    download: fakeDownload,
+    isGitAvailable: async () => false,
+    ensureGit: async () => {},
+    postProcess: async () => {},
+    finalize: async () => {}
+  });
+  assert.ok(downloaded);
+  const pkg = JSON.parse(await fs.readFile(path.join(tmp, 'package.json'), 'utf8'));
+  assert.equal(pkg.name, 'forced');
+});