@superblocksteam/sdk 2.0.114 → 2.0.115-next.1

package/test/vite-dev-server-diagnostics.test.mts

@@ -0,0 +1,336 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildViteBuildErrorLog,
+  diagnoseViteBuildLogMessage,
+  formatViteBuildErrorLogSummary,
+  formatViteDevServerStartedLog,
+  logViteBuildError,
+  truncateViteRawLog,
+  VITE_ERROR_RAW_LOG_MAX_CHARS,
+  viteErrorKindForDiagnostic,
+} from "../src/dev-utils/vite-dev-server-diagnostics.mjs";
+
+describe("diagnoseViteBuildLogMessage", () => {
+  it("detects esbuild could not resolve with double quotes", () => {
+    const msg = String.raw`✘ [ERROR] Could not resolve "@opentelemetry/api"
+
+    node_modules/foo/MetricStorageRegistry.js:28:21:`;
+    expect(diagnoseViteBuildLogMessage(msg)).toEqual({
+      category: "module_resolve",
+      unresolvedSpecifier: "@opentelemetry/api",
+    });
+  });
+
+  it("detects could not resolve with single quotes", () => {
+    expect(
+      diagnoseViteBuildLogMessage("Could not resolve 'lodash/missing'"),
+    ).toEqual({
+      category: "module_resolve",
+      unresolvedSpecifier: "lodash/missing",
+    });
+  });
+
+  it("detects optimizeDeps-related output without resolve line", () => {
+    expect(
+      diagnoseViteBuildLogMessage(
+        "Error: optimizeDeps failed during pre-bundling",
+      ),
+    ).toEqual({ category: "optimize_deps" });
+  });
+
+  it("returns unknown when no pattern matches", () => {
+    expect(diagnoseViteBuildLogMessage("Something else broke")).toEqual({
+      category: "unknown",
+    });
+  });
+});
+
+describe("formatViteBuildErrorLogSummary", () => {
+  it("includes stable tokens and unresolved_specifier when present", () => {
+    const summary = formatViteBuildErrorLogSummary({
+      diagnostic: {
+        category: "module_resolve",
+        unresolvedSpecifier: "@opentelemetry/api",
+      },
+      sdkVersion: "2.0.1",
+      viteRootBasename: "my-app",
+    });
+    expect(summary).toBe(
+      "sdk_dev_server_vite_error sdk_version=2.0.1 vite_root=my-app category=module_resolve unresolved_specifier=@opentelemetry/api",
+    );
+  });
+
+  it("quotes values with spaces so log facets stay parseable", () => {
+    const summary = formatViteBuildErrorLogSummary({
+      diagnostic: {
+        category: "module_resolve",
+        unresolvedSpecifier: "@scope/pkg with spaces",
+      },
+      sdkVersion: "2.0.1",
+      viteRootBasename: "my app",
+    });
+    expect(summary).toBe(
+      'sdk_dev_server_vite_error sdk_version=2.0.1 vite_root="my app" category=module_resolve unresolved_specifier="@scope/pkg with spaces"',
+    );
+  });
+
+  it("omits unresolved_specifier for optimize_deps diagnostics", () => {
+    const summary = formatViteBuildErrorLogSummary({
+      diagnostic: {
+        category: "optimize_deps",
+      },
+      sdkVersion: "2.0.1",
+      viteRootBasename: "my-app",
+    });
+    expect(summary).toBe(
+      "sdk_dev_server_vite_error sdk_version=2.0.1 vite_root=my-app category=optimize_deps",
+    );
+  });
+
+  it("omits unresolved_specifier for unknown diagnostics", () => {
+    const summary = formatViteBuildErrorLogSummary({
+      diagnostic: {
+        category: "unknown",
+      },
+      sdkVersion: "2.0.1",
+      viteRootBasename: "my-app",
+    });
+    expect(summary).toBe(
+      "sdk_dev_server_vite_error sdk_version=2.0.1 vite_root=my-app category=unknown",
+    );
+  });
+});
+
+describe("viteErrorKindForDiagnostic", () => {
+  it("maps categories to stable error kinds", () => {
+    expect(
+      viteErrorKindForDiagnostic({
+        category: "module_resolve",
+        unresolvedSpecifier: "x",
+      }),
+    ).toBe("ViteModuleResolveError");
+    expect(viteErrorKindForDiagnostic({ category: "optimize_deps" })).toBe(
+      "ViteOptimizeDepsError",
+    );
+    expect(viteErrorKindForDiagnostic({ category: "unknown" })).toBe(
+      "ViteBuildError",
+    );
+  });
+
+  it("throws for an unexpected runtime category", () => {
+    expect(() =>
+      viteErrorKindForDiagnostic({
+        category: "unexpected",
+      } as unknown as Parameters<typeof viteErrorKindForDiagnostic>[0]),
+    ).toThrow("Unhandled Vite build diagnostic category: unexpected");
+  });
+});
+
+describe("formatViteDevServerStartedLog", () => {
+  it("emits a single-line ready line for log facets", () => {
+    expect(
+      formatViteDevServerStartedLog({
+        sdkVersion: "2.0.1",
+        viteRootBasename: "my-app",
+      }),
+    ).toBe("sdk_dev_server_vite_ready sdk_version=2.0.1 vite_root=my-app");
+  });
+
+  it("quotes vite_root when it contains spaces", () => {
+    expect(
+      formatViteDevServerStartedLog({
+        sdkVersion: "2.0.1",
+        viteRootBasename: "my app",
+      }),
+    ).toBe('sdk_dev_server_vite_ready sdk_version=2.0.1 vite_root="my app"');
+  });
+});
+
+describe("buildViteBuildErrorLog", () => {
+  it("builds a structured module_resolve payload on the happy path", () => {
+    expect(
+      buildViteBuildErrorLog({
+        rawMessage: 'Could not resolve "@opentelemetry/api"',
+        sdkVersion: "2.0.1",
+        viteRootBasename: "my-app",
+      }),
+    ).toEqual({
+      error: {
+        kind: "ViteModuleResolveError",
+        message: "Could not resolve: @opentelemetry/api",
+        stack: 'Could not resolve "@opentelemetry/api"',
+      },
+      message:
+        "sdk_dev_server_vite_error sdk_version=2.0.1 vite_root=my-app category=module_resolve unresolved_specifier=@opentelemetry/api",
+    });
+  });
+
+  it("falls back to a raw error payload if summary formatting fails", () => {
+    const result = buildViteBuildErrorLog(
+      {
+        rawMessage: 'Could not resolve "@opentelemetry/api"',
+        sdkVersion: "2.0.1",
+        viteRootBasename: "my-app",
+      },
+      {
+        formatSummary: () => {
+          throw new Error("boom");
+        },
+      },
+    );
+
+    expect(result).toEqual({
+      error: {
+        kind: "ViteBuildError",
+        message: "Vite or esbuild reported an error",
+        stack: 'Could not resolve "@opentelemetry/api"',
+      },
+      message:
+        "sdk_dev_server_vite_error sdk_version=2.0.1 vite_root=my-app category=unknown",
+    });
+  });
+});
+
+describe("logViteBuildError", () => {
+  it("logs structured message and error metadata on the happy path", () => {
+    const calls: Array<{ message: string; meta?: unknown }> = [];
+    const logger = {
+      error: (message: string, meta?: unknown) => {
+        calls.push({ message, meta });
+      },
+    };
+
+    logViteBuildError(logger, {
+      rawMessage: 'Could not resolve "@opentelemetry/api"',
+      sdkVersion: "2.0.1",
+      viteRootBasename: "my-app",
+    });
+
+    expect(calls).toEqual([
+      {
+        message:
+          "sdk_dev_server_vite_error sdk_version=2.0.1 vite_root=my-app category=module_resolve unresolved_specifier=@opentelemetry/api",
+        meta: {
+          error: {
+            kind: "ViteModuleResolveError",
+            message: "Could not resolve: @opentelemetry/api",
+            stack: 'Could not resolve "@opentelemetry/api"',
+          },
+        },
+      },
+    ]);
+  });
+
+  it("logs the raw vite message if building the structured payload throws", () => {
+    const calls: Array<{ message: string; meta?: unknown }> = [];
+    const logger = {
+      error: (message: string, meta?: unknown) => {
+        void meta;
+        calls.push({ message, meta });
+      },
+    };
+
+    expect(() =>
+      logViteBuildError(
+        logger,
+        {
+          rawMessage: 'Could not resolve "@opentelemetry/api"',
+          sdkVersion: "2.0.1",
+          viteRootBasename: "my-app",
+        },
+        {
+          build: () => {
+            throw new Error("boom");
+          },
+        },
+      ),
+    ).not.toThrow();
+
+    expect(calls).toEqual([
+      {
+        message: 'Could not resolve "@opentelemetry/api"',
+        meta: {
+          error: {
+            kind: "ViteDiagnosticsError",
+            message: "boom",
+            stack: 'Could not resolve "@opentelemetry/api"',
+          },
+        },
+      },
+    ]);
+  });
+
+  it("falls back with diagnostics context if the structured emit throws", () => {
+    const calls: Array<{ message: string; meta?: unknown }> = [];
+    let firstCall = true;
+    const logger = {
+      error: (message: string, meta?: unknown) => {
+        if (firstCall) {
+          firstCall = false;
+          throw new Error("transport failed");
+        }
+        calls.push({ message, meta });
+      },
+    };
+
+    expect(() =>
+      logViteBuildError(logger, {
+        rawMessage: 'Could not resolve "@opentelemetry/api"',
+        sdkVersion: "2.0.1",
+        viteRootBasename: "my-app",
+      }),
+    ).not.toThrow();
+
+    expect(calls).toEqual([
+      {
+        message: 'Could not resolve "@opentelemetry/api"',
+        meta: {
+          error: {
+            kind: "ViteDiagnosticsError",
+            message: "transport failed",
+            stack: 'Could not resolve "@opentelemetry/api"',
+          },
+        },
+      },
+    ]);
+  });
+
+  it("never throws even if the fallback logger throws too", () => {
+    let callCount = 0;
+    const logger = {
+      error: () => {
+        callCount += 1;
+        throw new Error("logger failed");
+      },
+    };
+
+    expect(() =>
+      logViteBuildError(logger, {
+        rawMessage: 'Could not resolve "@opentelemetry/api"',
+        sdkVersion: "2.0.1",
+        viteRootBasename: "my-app",
+      }),
+    ).not.toThrow();
+
+    expect(callCount).toBe(2);
+  });
+});
+
+describe("truncateViteRawLog", () => {
+  it("returns shorter logs unchanged", () => {
+    expect(truncateViteRawLog("short")).toBe("short");
+  });
+
+  it("returns exact-boundary logs unchanged", () => {
+    const exact = "a".repeat(VITE_ERROR_RAW_LOG_MAX_CHARS);
+    expect(truncateViteRawLog(exact)).toBe(exact);
+  });
+
+  it("truncates very long esbuild output", () => {
+    const long = "a".repeat(VITE_ERROR_RAW_LOG_MAX_CHARS + 100);
+    const out = truncateViteRawLog(long);
+    expect(out.length).toBeLessThanOrEqual(VITE_ERROR_RAW_LOG_MAX_CHARS + 30);
+    expect(out).toContain("...(truncated)");
+  });
+});