improve testability of versionCheck.ts

Author: bhouston

src/utils/versionCheck.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  isGlobalPackage,
+  generateUpgradeMessage,
+  fetchLatestVersion,
+  getPackageInfo,
+  checkForUpdates,
+} from "./versionCheck.js";
+
+// eslint-disable-next-line max-lines-per-function
+describe("versionCheck", () => {
+  describe("isGlobalPackage", () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it("returns true when npm_config_global is set", () => {
+      process.env.npm_config_global = "true";
+      expect(isGlobalPackage()).toBe(true);
+    });
+
+    it("returns false when npm_config_global is not set", () => {
+      delete process.env.npm_config_global;
+      expect(isGlobalPackage()).toBe(false);
+    });
+  });
+
+  describe("generateUpgradeMessage", () => {
+    it("returns null when versions are the same", () => {
+      expect(generateUpgradeMessage("1.0.0", "1.0.0", "test-package")).toBe(
+        null,
+      );
+    });
+
+    it("returns upgrade message when versions differ", () => {
+      const message = generateUpgradeMessage("1.0.0", "1.1.0", "test-package");
+      expect(message).toContain("Update available: 1.0.0 → 1.1.0");
+      expect(message).toContain("Run 'npm install -g test-package' to update");
+    });
+  });
+
+  describe("fetchLatestVersion", () => {
+    const mockFetch = vi.fn();
+    const originalFetch = global.fetch;
+
+    beforeEach(() => {
+      global.fetch = mockFetch;
+    });
+
+    afterEach(() => {
+      global.fetch = originalFetch;
+      vi.clearAllMocks();
+    });
+
+    it("returns version when fetch succeeds", async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ version: "1.1.0" }),
+      });
+
+      const version = await fetchLatestVersion("test-package");
+      expect(version).toBe("1.1.0");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://registry.npmjs.org/test-package/latest",
+      );
+    });
+
+    it("returns null when fetch fails", async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        statusText: "Not Found",
+      });
+
+      const version = await fetchLatestVersion("test-package");
+      expect(version).toBe(null);
+    });
+  });
+
+  describe("getPackageInfo", () => {
+    it("returns package info from package.json", () => {
+      const info = getPackageInfo();
+      expect(info).toHaveProperty("name");
+      expect(info).toHaveProperty("version");
+      expect(typeof info.name).toBe("string");
+      expect(typeof info.version).toBe("string");
+    });
+  });
+
+  describe("checkForUpdates", () => {
+    const mockFetch = vi.fn();
+    const originalFetch = global.fetch;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      global.fetch = mockFetch;
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      global.fetch = originalFetch;
+      process.env = originalEnv;
+      vi.clearAllMocks();
+    });
+
+    it("returns null when not running as global package", async () => {
+      delete process.env.npm_config_global;
+      const result = await checkForUpdates();
+      expect(result).toBe(null);
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it("returns upgrade message when update available", async () => {
+      process.env.npm_config_global = "true";
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ version: "999.0.0" }), // Much higher version
+      });
+
+      const result = await checkForUpdates();
+      expect(result).toContain("Update available");
+    });
+  });
+});

src/utils/versionCheck.ts

@@ -3,9 +3,67 @@ import { createRequire } from "module";
 import type { PackageJson } from "type-fest";
 
 const require = createRequire(import.meta.url);
-const packageInfo = require("../../package.json") as PackageJson;
 const logger = new Logger({ name: "version-check" });
 
+/**
+ * Gets the current package info from package.json
+ */
+export function getPackageInfo(): {
+  name: string | undefined;
+  version: string | undefined;
+} {
+  const packageInfo = require("../../package.json") as PackageJson;
+  return {
+    name: packageInfo.name,
+    version: packageInfo.version,
+  };
+}
+
+/**
+ * Checks if the package is running as a global npm package
+ */
+export function isGlobalPackage(): boolean {
+  return !!process.env.npm_config_global;
+}
+
+/**
+ * Fetches the latest version of a package from npm registry
+ */
+export async function fetchLatestVersion(
+  packageName: string,
+): Promise<string | null> {
+  try {
+    const registryUrl = `https://registry.npmjs.org/${packageName}/latest`;
+    const response = await fetch(registryUrl);
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch version info: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as { version: string | undefined };
+    return data.version ?? null;
+  } catch (error) {
+    logger.warn(
+      "Error fetching latest version:",
+      error instanceof Error ? error.message : String(error),
+    );
+    return null;
+  }
+}
+
+/**
+ * Generates an upgrade message if versions differ
+ */
+export function generateUpgradeMessage(
+  currentVersion: string,
+  latestVersion: string,
+  packageName: string,
+): string | null {
+  return currentVersion !== latestVersion
+    ? `Update available: ${currentVersion} → ${latestVersion}\nRun 'npm install -g ${packageName}' to update`
+    : null;
+}
+
 /**
  * Checks if a newer version of the package is available on npm.
  * Only runs check when package is installed globally.
@@ -15,45 +73,30 @@ const logger = new Logger({ name: "version-check" });
 export async function checkForUpdates(): Promise<string | null> {
   try {
     // Only check for updates if running as global package
-    if (!process.env.npm_config_global) {
+    if (!isGlobalPackage()) {
       return null;
     }
 
-    const packageName = packageInfo.name;
-    const currentVersion = packageInfo.version;
+    const { name: packageName, version: currentVersion } = getPackageInfo();
 
     if (!packageName || !currentVersion) {
       logger.warn("Unable to determine current package name or version");
       return null;
     }
 
-    // Fetch latest version from npm registry
-    const registryUrl = `https://registry.npmjs.org/${packageName}/latest`;
-    const response = await fetch(registryUrl);
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch version info: ${response.statusText}`);
-    }
-
-    const data = (await response.json()) as { version: string | undefined };
-    const latestVersion = data.version;
+    const latestVersion = await fetchLatestVersion(packageName);
 
     if (!latestVersion) {
-      logger.warn("Unable to determine determine latest published version");
+      logger.warn("Unable to determine latest published version");
       return null;
     }
 
-    // Compare versions
-    if (currentVersion !== latestVersion) {
-      return `Update available: ${currentVersion} → ${latestVersion}\nRun 'npm install -g ${packageName}' to update`;
-    }
-
-    return null;
+    return generateUpgradeMessage(currentVersion, latestVersion, packageName);
   } catch (error) {
     // Log error but don't throw to handle gracefully
     logger.warn(
       "Error checking for updates:",
-      error instanceof Error ? error.message : String(error)
+      error instanceof Error ? error.message : String(error),
     );
     return null;
   }