test: add mock tracking diagnostics for Forgejo CI debugging

DI fix passes locally in grunt-runner Docker but still fails on
actual Forgejo runner. Adding diagnostic tests to isolate whether
mock() tracking itself is broken, or something else in the runner
environment causes it.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

test/debug-mock-tracking.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Diagnostic test file to debug mock tracking failures on Forgejo CI.
+ * Tests pass locally (macOS + Docker grunt-runner) but image-downloader
+ * tests fail on the actual Forgejo runner. This file isolates mock/spy
+ * tracking behavior to find the exact failure point.
+ *
+ * DELETE THIS FILE once the root cause is found and fixed.
+ */
+import {
+  describe,
+  test,
+  expect,
+  spyOn,
+  mock,
+  beforeEach,
+  afterEach,
+} from "bun:test";
+
+describe("DEBUG: mock tracking diagnostics", () => {
+  test("basic mock() tracks calls", () => {
+    const fn = mock(() => 42);
+    fn("hello");
+    console.log("[DIAG] mock.calls:", JSON.stringify(fn.mock.calls));
+    expect(fn).toHaveBeenCalledWith("hello");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  test("mock() tracks calls through object property", () => {
+    const obj = { method: mock(() => "ok") };
+    obj.method("arg1", "arg2");
+    console.log(
+      "[DIAG] obj.method.mock.calls:",
+      JSON.stringify(obj.method.mock.calls),
+    );
+    expect(obj.method).toHaveBeenCalledWith("arg1", "arg2");
+  });
+
+  test("mock() tracks calls after destructuring", () => {
+    const fn = mock(() => Promise.resolve("done"));
+    const obj = { fn };
+    const { fn: extracted } = obj;
+    extracted("test");
+    console.log(
+      "[DIAG] destructured mock.calls:",
+      JSON.stringify(fn.mock.calls),
+    );
+    expect(fn).toHaveBeenCalledWith("test");
+  });
+
+  test("mock() tracks calls when passed as parameter", async () => {
+    const mockFn = mock(() => Promise.resolve(undefined));
+    const deps = { action: mockFn as (...args: unknown[]) => Promise<void> };
+
+    async function doWork(d: {
+      action: (...args: unknown[]) => Promise<void>;
+    }) {
+      const { action } = d;
+      await action("path", { recursive: true });
+    }
+
+    await doWork(deps);
+    console.log(
+      "[DIAG] param-passed mock.calls:",
+      JSON.stringify(mockFn.mock.calls),
+    );
+    expect(mockFn).toHaveBeenCalledWith("path", { recursive: true });
+  });
+
+  test("spyOn(console) tracks calls", () => {
+    const spy = spyOn(console, "warn").mockImplementation(() => {});
+    console.warn("test warning");
+    // Check raw calls before expect
+    console.log(
+      "[DIAG] console.warn spy.mock.calls:",
+      JSON.stringify(spy.mock.calls),
+    );
+    expect(spy).toHaveBeenCalledWith("test warning");
+    spy.mockRestore();
+  });
+
+  test("spyOn(global, 'fetch') tracks calls", async () => {
+    const fetchSpy = spyOn(global, "fetch").mockResolvedValue({
+      ok: true,
+      arrayBuffer: async () => new ArrayBuffer(0),
+    } as Response);
+    await fetch("https://example.com");
+    console.log(
+      "[DIAG] fetch spy.mock.calls:",
+      JSON.stringify(fetchSpy.mock.calls),
+    );
+    expect(fetchSpy).toHaveBeenCalledWith("https://example.com");
+    fetchSpy.mockRestore();
+  });
+
+  test("mock() with mockClear preserves tracking", () => {
+    const fn = mock(() => "first");
+    fn("before-clear");
+    fn.mockClear();
+    fn("after-clear");
+    console.log(
+      "[DIAG] after mockClear, calls:",
+      JSON.stringify(fn.mock.calls),
+    );
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith("after-clear");
+  });
+
+  describe("mock created at describe scope", () => {
+    const describeMock = mock(() => Promise.resolve(undefined as any));
+
+    beforeEach(() => {
+      describeMock.mockClear();
+    });
+
+    test("tracks calls from describe-scoped mock", async () => {
+      await describeMock("test-arg");
+      console.log(
+        "[DIAG] describe-scope mock.calls:",
+        JSON.stringify(describeMock.mock.calls),
+      );
+      expect(describeMock).toHaveBeenCalledWith("test-arg");
+    });
+
+    test("tracks calls via DI pattern (like image-downloader)", async () => {
+      const deps = {
+        mkdir: describeMock as any,
+      };
+
+      // Simulate the exact pattern from image-downloader.ts
+      const { mkdir } = deps;
+      await mkdir("/tmp/github-images", { recursive: true });
+
+      console.log(
+        "[DIAG] DI-pattern mock.calls:",
+        JSON.stringify(describeMock.mock.calls),
+      );
+      expect(describeMock).toHaveBeenCalledWith("/tmp/github-images", {
+        recursive: true,
+      });
+    });
+  });
+
+  describe("env var diagnostics", () => {
+    test("GITHUB_SERVER_URL value", () => {
+      console.log("[DIAG] GITHUB_SERVER_URL:", process.env.GITHUB_SERVER_URL);
+      console.log("[DIAG] FORGEJO:", process.env.FORGEJO);
+      console.log("[DIAG] RUNNER_OS:", process.env.RUNNER_OS);
+      console.log("[DIAG] Bun.version:", Bun.version);
+      console.log("[DIAG] process.arch:", process.arch);
+      console.log("[DIAG] process.platform:", process.platform);
+      expect(true).toBe(true);
+    });
+  });
+});