@simplysm/sd-cli 14.0.16 → 14.0.18

package/tests/utils/vite-pwa-plugin.acc.spec.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { Plugin } from "vite";
+import fs from "node:fs";
+
+// --- Mock factories ---
+
+const mockGeneratePwaIcons = vi.fn();
+vi.mock("../../src/utils/generate-pwa-icons.js", () => ({
+  generatePwaIcons: mockGeneratePwaIcons,
+}));
+
+const mockGlob = vi.fn();
+vi.mock("glob", () => ({
+  glob: mockGlob,
+}));
+
+// --- Dynamic import ---
+
+const { sdPwaPlugin } = await import("../../src/utils/vite-pwa-plugin");
+
+// --- Helpers ---
+
+function createPlugin(
+  overrides?: Partial<Parameters<typeof sdPwaPlugin>[0]>,
+): Plugin {
+  return sdPwaPlugin({
+    pkgDir: "/packages/test-app",
+    pkgName: "test-app",
+    ...overrides,
+  }) as Plugin;
+}
+
+function initPlugin(plugin: Plugin): void {
+  (plugin.configResolved as Function)({
+    base: "/test-app/",
+    build: { outDir: "/packages/test-app/dist" },
+  });
+}
+
+function getManifestWriteCall(): [string, string] | undefined {
+  return vi.mocked(fs.writeFileSync).mock.calls.find((c) =>
+    String(c[0]).includes("manifest.webmanifest"),
+  ) as [string, string] | undefined;
+}
+
+function parseWrittenManifest(): Record<string, unknown> {
+  const call = getManifestWriteCall();
+  if (call == null) throw new Error("manifest.webmanifest not written");
+  return JSON.parse(call[1]);
+}
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockGeneratePwaIcons.mockResolvedValue([]);
+  mockGlob.mockResolvedValue([]);
+  vi.spyOn(fs, "readFileSync").mockReturnValue(
+    JSON.stringify({ version: "1.0.0" }),
+  );
+  vi.spyOn(fs, "writeFileSync").mockReturnValue(undefined);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("sdPwaPlugin — Acceptance: Slice 1 manifest 생성", () => {
+  // Scenario: 기본 manifest 생성
+  it("generates manifest.webmanifest with default fields when pwa is empty", async () => {
+    const plugin = createPlugin({ pwa: {} });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const manifest = parseWrittenManifest();
+    expect(manifest["name"]).toBe("test-app");
+    expect(manifest["short_name"]).toBe("test-app");
+    expect(manifest["display"]).toBe("standalone");
+    expect(manifest["theme_color"]).toBe("#ffffff");
+    expect(manifest["background_color"]).toBe("#ffffff");
+    expect(manifest["start_url"]).toBe(".");
+  });
+
+  // Scenario: manifest 필드 커스텀
+  it("applies custom manifest fields from SdPwaConfig", async () => {
+    const plugin = createPlugin({
+      pwa: { manifest: { name: "My App", theme_color: "#000000" } },
+    });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const manifest = parseWrittenManifest();
+    expect(manifest["name"]).toBe("My App");
+    expect(manifest["theme_color"]).toBe("#000000");
+    expect(manifest["short_name"]).toBe("test-app");
+    expect(manifest["display"]).toBe("standalone");
+  });
+
+  // Scenario: 기본 아이콘 자동 생성
+  it("includes generated icons in manifest when no custom icons", async () => {
+    mockGeneratePwaIcons.mockResolvedValue([
+      { src: "icons/icon-192x192.png", sizes: "192x192", type: "image/png" },
+    ]);
+
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    expect(mockGeneratePwaIcons).toHaveBeenCalledWith("/packages/test-app");
+    const manifest = parseWrittenManifest();
+    expect(manifest["icons"]).toEqual([
+      { src: "icons/icon-192x192.png", sizes: "192x192", type: "image/png" },
+    ]);
+  });
+
+  // Scenario: 커스텀 아이콘 설정 시 자동 생성 건너뜀
+  it("uses custom icons and skips generatePwaIcons", async () => {
+    const icons = [
+      { src: "/custom.png", sizes: "512x512", type: "image/png" },
+    ];
+    const plugin = createPlugin({
+      pwa: { manifest: { icons } },
+    });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    expect(mockGeneratePwaIcons).not.toHaveBeenCalled();
+    const manifest = parseWrittenManifest();
+    expect(manifest["icons"]).toEqual(icons);
+  });
+
+  // Scenario: 원본 아이콘 없음
+  it("omits icons field when generatePwaIcons returns empty array", async () => {
+    mockGeneratePwaIcons.mockResolvedValue([]);
+
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const manifest = parseWrittenManifest();
+    expect(manifest["icons"]).toBeUndefined();
+  });
+});

package/tests/utils/vite-pwa-plugin.spec.ts

@@ -0,0 +1,350 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { Plugin } from "vite";
+import fs from "node:fs";
+
+// --- Mock factories ---
+
+const mockGeneratePwaIcons = vi.fn();
+vi.mock("../../src/utils/generate-pwa-icons.js", () => ({
+  generatePwaIcons: mockGeneratePwaIcons,
+}));
+
+const mockGlob = vi.fn();
+vi.mock("glob", () => ({
+  glob: mockGlob,
+}));
+
+// --- Dynamic import ---
+
+const { sdPwaPlugin } = await import("../../src/utils/vite-pwa-plugin");
+
+// --- Helpers ---
+
+function createPlugin(
+  overrides?: Partial<Parameters<typeof sdPwaPlugin>[0]>,
+): Plugin {
+  return sdPwaPlugin({
+    pkgDir: "/packages/test-app",
+    pkgName: "test-app",
+    ...overrides,
+  }) as Plugin;
+}
+
+function initPlugin(plugin: Plugin): void {
+  (plugin.configResolved as Function)({
+    base: "/test-app/",
+    build: { outDir: "/packages/test-app/dist" },
+  });
+}
+
+function getWriteCall(filename: string): [string, string] | undefined {
+  return vi.mocked(fs.writeFileSync).mock.calls.find((c) =>
+    String(c[0]).endsWith(filename),
+  ) as [string, string] | undefined;
+}
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockGeneratePwaIcons.mockResolvedValue([]);
+  mockGlob.mockResolvedValue([]);
+  vi.spyOn(fs, "readFileSync").mockReturnValue(
+    JSON.stringify({ version: "1.0.0" }),
+  );
+  vi.spyOn(fs, "writeFileSync").mockReturnValue(undefined);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("sdPwaPlugin — manifest generation", () => {
+  // Unit: pwa undefined uses same defaults as empty object
+  it("uses defaults when pwa is undefined", async () => {
+    const plugin = createPlugin({ pwa: undefined });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const call = getWriteCall("manifest.webmanifest");
+    expect(call).toBeDefined();
+    const manifest = JSON.parse(call![1]) as Record<string, unknown>;
+    expect(manifest["name"]).toBe("test-app");
+    expect(manifest["scope"]).toBe(".");
+  });
+
+  // Unit: manifest written to correct outDir path
+  it("writes manifest to resolvedOutDir", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const call = getWriteCall("manifest.webmanifest");
+    const writtenPath = String(call![0]).replace(/\\/g, "/");
+    expect(writtenPath).toContain("packages/test-app/dist");
+  });
+
+  // Unit: all manifest fields can be overridden
+  it("overrides all customizable manifest fields", async () => {
+    const plugin = createPlugin({
+      pwa: {
+        manifest: {
+          name: "A",
+          short_name: "B",
+          display: "fullscreen",
+          theme_color: "#111",
+          background_color: "#222",
+        },
+      },
+    });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const manifest = JSON.parse(getWriteCall("manifest.webmanifest")![1]) as Record<
+      string,
+      unknown
+    >;
+    expect(manifest["name"]).toBe("A");
+    expect(manifest["short_name"]).toBe("B");
+    expect(manifest["display"]).toBe("fullscreen");
+    expect(manifest["theme_color"]).toBe("#111");
+    expect(manifest["background_color"]).toBe("#222");
+  });
+});
+
+describe("sdPwaPlugin — precache file collection", () => {
+  // Unit: default globPatterns
+  it("uses default globPatterns when workbox is not configured", async () => {
+    mockGlob.mockResolvedValue(["index.html", "assets/main.js"]);
+
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    expect(mockGlob).toHaveBeenCalledWith(
+      "**/*.{js,css,html,ico,png,svg,woff2}",
+      { cwd: "/packages/test-app/dist" },
+    );
+  });
+
+  // Unit: custom globPatterns
+  it("uses custom globPatterns from workbox config", async () => {
+    mockGlob.mockResolvedValue(["index.html"]);
+
+    const plugin = createPlugin({
+      pwa: { workbox: { globPatterns: ["**/*.{js,html}"] } },
+    });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    expect(mockGlob).toHaveBeenCalledWith("**/*.{js,html}", expect.anything());
+  });
+
+  // Unit: excludes sw.js and manifest.webmanifest from precache
+  it("excludes sw.js and manifest.webmanifest from precache list", async () => {
+    mockGlob.mockResolvedValue([
+      "index.html",
+      "main.js",
+      "sw.js",
+      "manifest.webmanifest",
+    ]);
+
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swCall = getWriteCall("sw.js");
+    const swContent = swCall![1];
+    expect(swContent).toContain('"index.html"');
+    expect(swContent).toContain('"main.js"');
+    expect(swContent).not.toMatch(/"sw\.js"/);
+    expect(swContent).not.toMatch(/"manifest\.webmanifest"/);
+  });
+
+  // Unit: deduplicates file list
+  it("deduplicates files matched by multiple patterns", async () => {
+    mockGlob
+      .mockResolvedValueOnce(["index.html", "main.js"])
+      .mockResolvedValueOnce(["index.html", "styles.css"]);
+
+    const plugin = createPlugin({
+      pwa: {
+        workbox: { globPatterns: ["**/*.{html,js}", "**/*.{html,css}"] },
+      },
+    });
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    // Extract only the PRECACHE_URLS array declaration
+    const precacheMatch = swContent.match(
+      /const PRECACHE_URLS = \[([\s\S]*?)\];/,
+    );
+    expect(precacheMatch).toBeDefined();
+    const precacheBlock = precacheMatch![1];
+    const htmlMatches = precacheBlock.match(/"index\.html"/g);
+    expect(htmlMatches).toHaveLength(1);
+  });
+});
+
+describe("sdPwaPlugin — sw.js generation", () => {
+  // Unit: version injected from package.json
+  it("injects APP_VERSION from package.json", async () => {
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ version: "14.0.16" }),
+    );
+
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('const APP_VERSION = "14.0.16"');
+    expect(swContent).toContain('"precache-" + APP_VERSION');
+  });
+
+  // Unit: base URL injected
+  it("injects BASE_URL from resolved config", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('const BASE_URL = "/test-app/"');
+  });
+
+  // Unit: sw.js contains all 4 event listeners
+  it("contains install, activate, fetch, and message event listeners", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('self.addEventListener("install"');
+    expect(swContent).toContain('self.addEventListener("activate"');
+    expect(swContent).toContain('self.addEventListener("fetch"');
+    expect(swContent).toContain('self.addEventListener("message"');
+  });
+
+  // Unit: install handler uses cache.addAll
+  it("install handler caches all precache URLs", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain("caches.open(CACHE_NAME)");
+    expect(swContent).toContain("cache.addAll(PRECACHE_URLS)");
+  });
+
+  // Unit: activate handler deletes old caches with precache- prefix only
+  it("activate handler filters by precache- prefix", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('name.startsWith("precache-")');
+    expect(swContent).toContain("name !== CACHE_NAME");
+    expect(swContent).toContain("self.clients.claim()");
+  });
+
+  // Unit: fetch handler has navigate fallback to index.html with network fallback
+  it("fetch handler falls back to index.html for navigate requests with network fallback", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('event.request.mode === "navigate"');
+    expect(swContent).toContain('BASE_URL + "index.html"');
+    // Network fallback when index.html is not in cache (storage pressure)
+    expect(swContent).toContain("resp || fetch(event.request)");
+  });
+
+  // Unit: message handler responds to SKIP_WAITING
+  it("message handler calls self.skipWaiting on SKIP_WAITING", async () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('"SKIP_WAITING"');
+    expect(swContent).toContain("self.skipWaiting()");
+  });
+
+  // Unit: backslash normalization in file paths
+  it("normalizes backslashes in precache URLs", async () => {
+    mockGlob.mockResolvedValue(["assets\\main.js"]);
+
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    await (plugin.closeBundle as Function)();
+
+    const swContent = getWriteCall("sw.js")![1];
+    expect(swContent).toContain('"assets/main.js"');
+    expect(swContent).not.toContain("\\\\");
+  });
+});
+
+describe("sdPwaPlugin — transformIndexHtml", () => {
+  // Unit: manifest link tag
+  it("injects manifest link tag", () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    const tags = (plugin.transformIndexHtml as Function)() as Array<{
+      tag: string;
+      attrs?: Record<string, string>;
+      injectTo?: string;
+    }>;
+
+    const linkTag = tags.find((t) => t.tag === "link");
+    expect(linkTag).toBeDefined();
+    expect(linkTag!.attrs!["rel"]).toBe("manifest");
+    expect(linkTag!.attrs!["href"]).toBe("manifest.webmanifest");
+  });
+
+  // Unit: SW registration script tag
+  it("injects SW registration script", () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    const tags = (plugin.transformIndexHtml as Function)() as Array<{
+      tag: string;
+      children?: string;
+      injectTo?: string;
+    }>;
+
+    const scriptTag = tags.find((t) => t.tag === "script");
+    expect(scriptTag).toBeDefined();
+    expect(scriptTag!.children).toContain("serviceWorker");
+    expect(scriptTag!.children).toContain('register("sw.js")');
+  });
+
+  // Unit: registration script dispatches sd-pwa-update-ready event
+  it("dispatches sd-pwa-update-ready CustomEvent", () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    const tags = (plugin.transformIndexHtml as Function)() as Array<{
+      tag: string;
+      children?: string;
+    }>;
+
+    const scriptTag = tags.find((t) => t.tag === "script");
+    expect(scriptTag!.children).toContain("sd-pwa-update-ready");
+    expect(scriptTag!.children).toContain("SKIP_WAITING");
+  });
+
+  // Unit: registration script reloads on controllerchange
+  it("reloads page on controllerchange", () => {
+    const plugin = createPlugin();
+    initPlugin(plugin);
+    const tags = (plugin.transformIndexHtml as Function)() as Array<{
+      tag: string;
+      children?: string;
+    }>;
+
+    const scriptTag = tags.find((t) => t.tag === "script");
+    expect(scriptTag!.children).toContain("controllerchange");
+    expect(scriptTag!.children).toContain("location.reload");
+  });
+});

package/tests/utils/worker-utils.spec.ts

@@ -1,13 +1,15 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
-import { applyDebugLevel, createOnceGuard, registerCleanupHandlers } from "../../src/utils/worker-utils";
+import { setupWorkerConsola, createOnceGuard, registerCleanupHandlers } from "../../src/utils/worker-utils";
 import consola, { LogLevels } from "consola";
 
-describe("applyDebugLevel", () => {
+describe("setupWorkerConsola", () => {
   const originalLevel = consola.level;
+  const originalReporters = [...consola.options.reporters];
   const originalEnv = process.env["SD_DEBUG"];
 
   afterEach(() => {
     consola.level = originalLevel;
+    consola.options.reporters = originalReporters;
     if (originalEnv === undefined) {
       delete process.env["SD_DEBUG"];
     } else {
@@ -17,15 +19,14 @@ describe("applyDebugLevel", () => {
 
   it("sets consola level to debug when SD_DEBUG is 'true'", () => {
     process.env["SD_DEBUG"] = "true";
-    applyDebugLevel();
+    setupWorkerConsola();
     expect(consola.level).toBe(LogLevels.debug);
   });
 
-  it("does not change level when SD_DEBUG is not set", () => {
+  it("sets consola level to debug even when SD_DEBUG is not set", () => {
     delete process.env["SD_DEBUG"];
-    const before = consola.level;
-    applyDebugLevel();
-    expect(consola.level).toBe(before);
+    setupWorkerConsola();
+    expect(consola.level).toBe(LogLevels.debug);
   });
 });
 

package/tests/workers/client-worker.spec.ts

@@ -75,7 +75,7 @@ vi.mock("consola", () => ({
 
 vi.mock("../../src/utils/worker-utils.js", () => ({
   registerCleanupHandlers: vi.fn(),
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
 }));
 
 //#endregion
@@ -522,6 +522,55 @@ describe("client.worker", () => {
     });
   });
 
+  // Acceptance: Scenario "Vite dev server 포트 확정 시 포트 파일 기록"
+  describe("dev port file", () => {
+    it("writes .dev-port after serverReady in dev mode", async () => {
+      const mockServer = {
+        listen: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined),
+        httpServer: { address: () => ({ port: 5173 }) },
+      };
+      mockCreateServer.mockResolvedValue(mockServer);
+
+      await workerFns["startWatch"]({
+        ...createBaseInfo(),
+        port: 5173,
+      });
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        expect.stringContaining(".dev-port"),
+        "5173",
+      );
+
+      await workerFns["stopWatch"]();
+    });
+
+    it("writes .dev-port after serverReady in legacy mode", async () => {
+      const mockWatcher = createMockWatcher();
+      mockViteBuild.mockImplementation(() => {
+        setTimeout(() => mockWatcher.emit("event", { code: "END" }), 0);
+        return Promise.resolve(mockWatcher);
+      });
+
+      mockExistsSync.mockReturnValue(false);
+
+      await workerFns["startWatch"]({
+        ...createBaseInfo(),
+        browserSupport: { legacyModule: true },
+        port: 0,
+      });
+
+      const port = mockSend.mock.calls.find((c: any[]) => c[0] === "serverReady")?.[1]?.port;
+
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        expect.stringContaining(".dev-port"),
+        String(port),
+      );
+
+      await workerFns["stopWatch"]();
+    });
+  });
+
   describe("startWatch — legacy live reload (Feature 1.3)", () => {
     // Acceptance: Scenario "index.html 서빙 시 reload 스크립트 자동 삽입"
     it("injects live reload script into HTML responses", async () => {

package/tests/workers/dev-port-file.verify.md

@@ -0,0 +1,6 @@
+# 포트 파일 기록/삭제 — LLM 검증
+
+## 검증 항목
+- [x] client.worker에서 dev 모드 serverReady 후 writeDevPort 호출: `client.worker.ts:250-253` — serverReady(248) 직후 `fs.writeFileSync(path.join(distDir, ".dev-port"), String(actualPort))` 확인
+- [x] client.worker에서 legacy 모드 serverReady 후 writeDevPort 호출: `client.worker.ts:331-332` — serverReady(329) 직후 `fs.writeFileSync(path.join(info.pkgDir, "dist", ".dev-port"), String(serverPort))` 확인
+- [x] ViteEngine.stop()에서 deleteDevPort 호출: `ViteEngine.ts:202-204` — `fs.unlinkSync(portFile)` with try-catch 확인

package/tests/workers/library-build-lint.spec.ts

@@ -35,7 +35,7 @@ vi.mock("../../src/utils/tsc-build", () => ({
 vi.mock("../../src/utils/worker-utils", () => ({
   registerCleanupHandlers: vi.fn(),
   createOnceGuard: vi.fn(() => vi.fn()),
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
 }));
 
 const mockConsolaLogger = {

package/tests/workers/library-build-worker.spec.ts

@@ -59,7 +59,7 @@ vi.mock("../../src/utils/tsc-build", () => ({
 }));
 
 vi.mock("../../src/utils/worker-utils", () => ({
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
   registerCleanupHandlers: vi.fn(),
   createOnceGuard: vi.fn(() => vi.fn()),
 }));

package/tests/workers/ngtsc-build-lint.spec.ts

@@ -72,7 +72,7 @@ vi.mock("typescript", async (importOriginal) => {
 vi.mock("../../src/utils/worker-utils", () => ({
   registerCleanupHandlers: vi.fn(),
   createOnceGuard: vi.fn(() => vi.fn()),
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
 }));
 
 vi.mock("../../src/utils/package-utils", () => ({

package/tests/workers/server-build-lint.spec.ts

@@ -53,7 +53,7 @@ vi.mock("esbuild", () => ({
 vi.mock("../../src/utils/worker-utils", () => ({
   registerCleanupHandlers: vi.fn(),
   createOnceGuard: vi.fn(() => vi.fn()),
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
 }));
 
 vi.mock("../../src/utils/copy-public", () => ({

package/tests/workers/server-build-worker.spec.ts

@@ -132,7 +132,7 @@ vi.mock("../../src/utils/worker-utils", () => ({
     if (guardCalled) throw new Error("startWatch has already been called");
     guardCalled = true;
   }),
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
 }));
 
 vi.mock("../../src/utils/package-utils", () => ({

package/tests/workers/server-runtime-worker.spec.ts

@@ -16,6 +16,13 @@ vi.mock("@simplysm/core-node", () => ({
 }));
 
 vi.mock("@simplysm/core-common", () => ({
+  env: vi.fn((key: string, value?: string) => {
+    if (value !== undefined) {
+      process.env[key] = value;
+      return;
+    }
+    return process.env[key];
+  }),
   err: { message: (e: any) => e?.message ?? String(e) },
 }));
 
@@ -32,7 +39,7 @@ vi.mock("consola", () => ({
 
 vi.mock("../../src/utils/worker-utils", () => ({
   registerCleanupHandlers: vi.fn(),
-  applyDebugLevel: vi.fn(),
+  setupWorkerConsola: vi.fn(),
 }));
 
 // @fastify/http-proxy mock