git0 0.2.64 → 0.2.65

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "git0",
     "description": "CLI tool to search GitHub repositories, download source & releases for your system, and instantly set up, then install dependencies and open code editor.",
-    "version": "0.2.64",
+    "version": "0.2.65",
     "author": "vtempest",
     "scripts": {
         "build": "bun build src/cli.ts --outdir dist --target node --format esm --sourcemap",

package/test/platform.test.ts

@@ -1,68 +1,61 @@
-import { describe, test, expect, mock, afterAll } from 'bun:test';
 import os from 'os';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { getCurrentPlatform } from '../src/platform.ts';
 
-// `mock.module` is process-global and is never rolled back on its own, so a
-// bare `{ platform, arch }` stub here would follow us into every test file
-// that bun happens to run afterwards (download.test.ts calls os.tmpdir()).
-// Keep the real module underneath the two functions we override, and put the
-// untouched module back once this file is done.
-const realOs = os;
-
+// Spy on the `os` default export rather than mocking the whole module: it is
+// the same object `src/platform.ts` imports, and the spies are restored after
+// every test so nothing leaks into the other suites (download.test.ts calls
+// os.tmpdir()).
 function mockPlatform(platform: string, arch: string) {
-  mock.module('os', () => ({ ...realOs, default: { ...realOs, platform: () => platform, arch: () => arch } }));
+  vi.spyOn(os, 'platform').mockReturnValue(platform as NodeJS.Platform);
+  vi.spyOn(os, 'arch').mockReturnValue(arch);
 }
 
-afterAll(() => {
-  mock.module('os', () => ({ ...realOs, default: realOs }));
+afterEach(() => {
+  vi.restoreAllMocks();
 });
 
 describe('getCurrentPlatform', () => {
-  test('maps darwin/x64 → macos/x86_64', async () => {
+  test('maps darwin/x64 → macos/x86_64', () => {
     mockPlatform('darwin', 'x64');
-    const fn = await load();
-    const p = fn();
+    const p = getCurrentPlatform();
     expect(p.os).toBe('macos');
     expect(p.arch).toBe('x86_64');
     expect(p.platform).toBe('darwin');
     expect(p.architecture).toBe('x64');
   });
 
-  test('maps win32/ia32 → windows/i386', async () => {
+  test('maps win32/ia32 → windows/i386', () => {
     mockPlatform('win32', 'ia32');
-    const fn = await load();
-    const p = fn();
+    const p = getCurrentPlatform();
     expect(p.os).toBe('windows');
     expect(p.arch).toBe('i386');
   });
 
-  test('maps linux/arm64 → linux/arm64', async () => {
+  test('maps linux/arm64 → linux/arm64', () => {
     mockPlatform('linux', 'arm64');
-    const fn = await load();
-    const p = fn();
+    const p = getCurrentPlatform();
     expect(p.os).toBe('linux');
     expect(p.arch).toBe('arm64');
   });
 
-  test('maps darwin/arm64 → macos/arm64 (Apple Silicon)', async () => {
+  test('maps darwin/arm64 → macos/arm64 (Apple Silicon)', () => {
     mockPlatform('darwin', 'arm64');
-    const fn = await load();
-    const p = fn();
+    const p = getCurrentPlatform();
     expect(p.os).toBe('macos');
     expect(p.arch).toBe('arm64');
   });
 
-  test('passes through unknown platform/arch as-is', async () => {
+  test('passes through unknown platform/arch as-is', () => {
     mockPlatform('freebsd', 'mips');
-    const fn = await load();
-    const p = fn();
+    const p = getCurrentPlatform();
     expect(p.os).toBe('freebsd');
     expect(p.arch).toBe('mips');
   });
 
-  test('returns raw platform and architecture fields alongside mapped ones', async () => {
+  test('returns raw platform and architecture fields alongside mapped ones', () => {
     mockPlatform('linux', 'x64');
-    const fn = await load();
-    const p = fn();
+    const p = getCurrentPlatform();
     expect(p.platform).toBe('linux');
     expect(p.architecture).toBe('x64');
   });