catalyst-core 1.0.2-canary.1 → 1.0.2

package/test/cli/spinner.test.ts

@@ -0,0 +1,177 @@
+import { createRequire } from "node:module"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import type spinnerModule from "../../src/cli/spinner.js"
+import type themeModule from "../../src/cli/theme.js"
+
+// Loaded with require, the way build.js and the native commands load them, so
+// v8 coverage sees one copy of each CommonJS file.
+const load = createRequire(import.meta.url)
+const { Spinner, withSpinnersPaused }: typeof spinnerModule = load("../../src/cli/spinner.js")
+const theme: typeof themeModule = load("../../src/cli/theme.js")
+
+const ESC = String.fromCharCode(27)
+const CLEAR_LINE = `\r${ESC}[2K`
+const plain = (text: string) => text.replace(theme.ANSI, "")
+
+// A stream that records every write, TTY or not.
+function fakeStream(isTTY: boolean) {
+    const writes: string[] = []
+    const stream = {
+        isTTY,
+        write: (chunk: string) => {
+            writes.push(String(chunk))
+            return true
+        },
+    }
+    return { stream: stream as unknown as typeof process.stdout, writes }
+}
+
+beforeEach(() => {
+    vi.useFakeTimers()
+    // isInteractive also requires CI to be unset, and CI sets it.
+    vi.stubEnv("CI", "")
+})
+
+afterEach(() => {
+    vi.useRealTimers()
+    vi.unstubAllEnvs()
+})
+
+describe("Spinner in a terminal", () => {
+    it("animates in place and settles into a timed result line", () => {
+        const { stream, writes } = fakeStream(true)
+        const spinner = new Spinner(stream).start("Building bundles")
+        expect(writes).toHaveLength(1)
+        expect(plain(writes[0])).toBe(`${CLEAR_LINE}  ◐ Building bundles`)
+
+        vi.advanceTimersByTime(120 * 4)
+        expect(writes.map(plain).slice(1)).toEqual(
+            ["◓", "◑", "◒", "◐"].map((frame) => `${CLEAR_LINE}  ${frame} Building bundles`)
+        )
+
+        spinner.update("Building client")
+        expect(plain(writes.at(-1) as string)).toBe(`${CLEAR_LINE}  ◐ Building client`)
+
+        vi.advanceTimersByTime(1000)
+        writes.length = 0
+        spinner.stop("done", "Built bundles")
+        expect(writes.map(plain)).toEqual([CLEAR_LINE, "  ✓ Built bundles  1.5s\n"])
+
+        // A stopped spinner neither redraws nor settles twice.
+        vi.advanceTimersByTime(1000)
+        spinner.stop()
+        expect(writes).toHaveLength(2)
+    })
+
+    it("marks a failure and keeps the label when none is given", () => {
+        const { stream, writes } = fakeStream(true)
+        const spinner = new Spinner(stream).start("Generating manifest")
+        writes.length = 0
+        spinner.stop("fail")
+        expect(writes.map(plain)).toEqual([CLEAR_LINE, "  ✗ Generating manifest\n"])
+    })
+
+    it("does not leave a second timer running when started twice", () => {
+        const { stream, writes } = fakeStream(true)
+        const spinner = new Spinner(stream).start("first")
+        spinner.start("second")
+        writes.length = 0
+        vi.advanceTimersByTime(120)
+        expect(writes.map(plain)).toEqual([`${CLEAR_LINE}  ◓ second`])
+        spinner.stop()
+    })
+
+    it("erases its row while paused and redraws on resume", () => {
+        const { stream, writes } = fakeStream(true)
+        const spinner = new Spinner(stream).start("Installing")
+        writes.length = 0
+
+        spinner.pause()
+        expect(writes).toEqual([CLEAR_LINE])
+        vi.advanceTimersByTime(1000)
+        expect(writes).toHaveLength(1)
+        // A paused spinner can be paused again without a second erase.
+        spinner.pause()
+        expect(writes).toHaveLength(2)
+
+        spinner.resume()
+        expect(plain(writes.at(-1) as string)).toBe(`${CLEAR_LINE}  ◐ Installing`)
+        // Already running: resuming again does nothing.
+        spinner.resume()
+        const count = writes.length
+        vi.advanceTimersByTime(120)
+        expect(writes).toHaveLength(count + 1)
+        spinner.stop()
+
+        // Stopped: pause and resume are both inert.
+        writes.length = 0
+        spinner.pause()
+        spinner.resume()
+        expect(writes).toEqual([])
+    })
+})
+
+describe("Spinner without a terminal", () => {
+    it("prints a plain start line and a plain result, with no escape codes", () => {
+        const { stream, writes } = fakeStream(false)
+        const spinner = new Spinner(stream).start("Building bundles")
+        spinner.update("Building client")
+        spinner.pause()
+        spinner.resume()
+        vi.advanceTimersByTime(2000)
+        spinner.stop("warn", "Built with warnings")
+
+        expect(writes.map(plain)).toEqual(["  · Building bundles\n", "  ▲ Built with warnings  2.0s\n"])
+        expect(writes.join("")).not.toContain("\r")
+    })
+
+    it("treats a TTY under CI as non-interactive", () => {
+        vi.stubEnv("CI", "true")
+        const { stream, writes } = fakeStream(true)
+        new Spinner(stream).start("Building").stop()
+        expect(writes.map(plain)).toEqual(["  · Building\n", "  ✓ Building\n"])
+    })
+
+    it("defaults to process.stdout", () => {
+        expect(new Spinner().stream).toBe(process.stdout)
+    })
+})
+
+describe("withSpinnersPaused", () => {
+    it("stands every live spinner down while fn runs and brings them back", async () => {
+        const { stream, writes } = fakeStream(true)
+        const spinner = new Spinner(stream).start("Configuring")
+        writes.length = 0
+
+        const result = await withSpinnersPaused(async () => {
+            expect(writes).toEqual([CLEAR_LINE])
+            return "answer"
+        })
+        expect(result).toBe("answer")
+        expect(plain(writes.at(-1) as string)).toBe(`${CLEAR_LINE}  ◐ Configuring`)
+        spinner.stop()
+    })
+
+    it("brings them back when fn throws", async () => {
+        const { stream, writes } = fakeStream(true)
+        const spinner = new Spinner(stream).start("Configuring")
+        writes.length = 0
+
+        await expect(
+            withSpinnersPaused(() => {
+                throw new Error("prompt failed")
+            })
+        ).rejects.toThrow("prompt failed")
+        expect(plain(writes.at(-1) as string)).toBe(`${CLEAR_LINE}  ◐ Configuring`)
+        spinner.stop()
+    })
+
+    it("leaves stopped spinners alone", async () => {
+        const { stream, writes } = fakeStream(true)
+        new Spinner(stream).start("Done already").stop()
+        writes.length = 0
+        await withSpinnersPaused(() => undefined)
+        expect(writes).toEqual([])
+    })
+})

package/test/cli/theme.test.ts

@@ -0,0 +1,163 @@
+import os from "os"
+import path from "path"
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+import { createRequire } from "module"
+import pkg from "../../package.json"
+import type themeModule from "../../src/cli/theme.js"
+
+// Loaded with require, the way diagnostic.js and the native commands load it:
+// v8 coverage then sees one copy of the file rather than two that it merges
+// badly across test files.
+const theme: typeof themeModule = createRequire(import.meta.url)("../../src/cli/theme.js")
+
+// theme.js is the shared visual language for every CLI command. Colour is
+// decided by ansis from the environment (it turns on under CI), so every
+// assertion here strips ANSI codes and checks what a reader would see.
+const { ANSI, GUTTER, glyph, SPINNER_FRAMES, t } = theme
+const plain = (text: string) => String(text).replace(ANSI, "")
+
+describe("theme constants", () => {
+    it("uses single-width glyphs and a calm four-frame spinner", () => {
+        for (const mark of [...Object.values(glyph), ...SPINNER_FRAMES]) {
+            expect([...mark]).toHaveLength(1)
+        }
+        expect(SPINNER_FRAMES).toEqual(["◐", "◓", "◑", "◒"])
+        expect(GUTTER).toBe("  ")
+    })
+
+    it("ANSI strips colour codes and nothing else", () => {
+        const esc = String.fromCharCode(27)
+        expect(`${esc}[36mcyan${esc}[39m ${esc}[1;31mbold red${esc}[0m`.replace(ANSI, "")).toBe(
+            "cyan bold red"
+        )
+        expect(plain(t.accent(t.bold("text")))).toBe("text")
+    })
+})
+
+describe("isInteractive", () => {
+    afterEach(() => {
+        vi.unstubAllEnvs()
+    })
+
+    it("is true only for a TTY outside CI", () => {
+        vi.stubEnv("CI", "")
+        const stream = (isTTY?: boolean) => ({ isTTY }) as unknown as typeof process.stdout
+        expect(theme.isInteractive(stream(true))).toBe(true)
+        expect(theme.isInteractive(stream(false))).toBe(false)
+        expect(theme.isInteractive(stream())).toBe(false)
+
+        vi.stubEnv("CI", "true")
+        expect(theme.isInteractive(stream(true))).toBe(false)
+    })
+})
+
+describe("isVerbose", () => {
+    it("is on for --verbose or --debug on this process", () => {
+        expect(theme.isVerbose(["node", "catalyst", "--verbose"], {})).toBe(true)
+        expect(theme.isVerbose(["node", "catalyst", "--debug"], {})).toBe(true)
+    })
+
+    it("is on when a parent forwarded the mode", () => {
+        expect(theme.isVerbose([], { CATALYST_OUTPUT_MODE: "verbose" })).toBe(true)
+        expect(theme.isVerbose([], { CATALYST_OUTPUT_MODE: "debug" })).toBe(true)
+    })
+
+    it("is off by default and for any other mode", () => {
+        expect(theme.isVerbose(["node", "catalyst", "build"], {})).toBe(false)
+        expect(theme.isVerbose([], { CATALYST_OUTPUT_MODE: "default" })).toBe(false)
+    })
+})
+
+describe("version and header", () => {
+    it("reads catalyst-core's own package version", () => {
+        expect(theme.version()).toBe(pkg.version)
+        // Cached: a second call returns the same value.
+        expect(theme.version()).toBe(pkg.version)
+    })
+
+    it("opens with title, version and subtitle over a rule", () => {
+        const lines = plain(theme.header("catalyst build", "production")).split("\n")
+        expect(lines).toEqual([
+            "",
+            `  catalyst build v${pkg.version}  ›  production`,
+            `  ${"─".repeat(46)}`,
+            "",
+        ])
+    })
+
+    it("omits the subtitle separator when there is no subtitle", () => {
+        const title = plain(theme.header("catalyst serve")).split("\n")[1]
+        expect(title).toBe(`  catalyst serve v${pkg.version}`)
+    })
+})
+
+describe("row", () => {
+    it("pads the key so values line up in one column", () => {
+        expect(plain(theme.row("Local", "http://localhost:3005"))).toBe("  Local    http://localhost:3005")
+        expect(plain(theme.row("Network", "http://10.0.0.2:3005"))).toBe("  Network  http://10.0.0.2:3005")
+        expect(plain(theme.row("a", "b", 3))).toBe("  a  b")
+    })
+})
+
+describe("duration", () => {
+    it("uses ms under a second, one decimal under a minute, then m/s", () => {
+        expect(theme.duration(0)).toBe("0ms")
+        expect(theme.duration(999)).toBe("999ms")
+        expect(theme.duration(1000)).toBe("1.0s")
+        expect(theme.duration(12345)).toBe("12.3s")
+        expect(theme.duration(60000)).toBe("1m 0s")
+        expect(theme.duration(125400)).toBe("2m 5s")
+    })
+})
+
+describe("bytes", () => {
+    it("picks B, kB or MB by size", () => {
+        expect(theme.bytes(0)).toBe("0 B")
+        expect(theme.bytes(1023)).toBe("1023 B")
+        expect(theme.bytes(1024)).toBe("1.0 kB")
+        expect(theme.bytes(1536)).toBe("1.5 kB")
+        expect(theme.bytes(1024 * 1024)).toBe("1.00 MB")
+        expect(theme.bytes(5.5 * 1024 * 1024)).toBe("5.50 MB")
+    })
+})
+
+describe("displayPath", () => {
+    const root = path.join(os.tmpdir(), "catalyst-app")
+
+    it("is relative when the file is inside the app", () => {
+        expect(theme.displayPath(path.join(root, "src", "App.js"), root)).toBe(path.join("src", "App.js"))
+    })
+
+    it("uses ~ for files under home but outside the app", () => {
+        const file = path.join(os.homedir(), "Library", "DerivedData", "Build.log")
+        expect(theme.displayPath(file, root)).toBe(
+            `~${path.sep}${path.join("Library", "DerivedData", "Build.log")}`
+        )
+    })
+
+    it("keeps absolute paths elsewhere, and the root itself", () => {
+        const outside = path.join(path.parse(root).root, "opt-catalyst-elsewhere", "file.js")
+        expect(theme.displayPath(outside, root)).toBe(outside)
+        expect(theme.displayPath(root, root)).toBe(root)
+    })
+
+    it("passes empty values through", () => {
+        expect(theme.displayPath(undefined, root)).toBeUndefined()
+        expect(theme.displayPath("", root)).toBe("")
+    })
+})
+
+describe("step", () => {
+    it("marks state with a glyph and shows meaningful timings", () => {
+        expect(plain(theme.step("Bundled client", 1200))).toBe("  ✓ Bundled client  1.2s")
+        expect(plain(theme.step("Type check", 250, "warn"))).toBe("  ▲ Type check  250ms")
+        expect(plain(theme.step("Gradle build", 61000, "fail"))).toBe("  ✗ Gradle build  1m 1s")
+    })
+
+    it("drops timings that are noise or missing", () => {
+        expect(plain(theme.step("Copied assets", 40))).toBe("  ✓ Copied assets")
+        expect(plain(theme.step("Copied assets"))).toBe("  ✓ Copied assets")
+        expect(plain(theme.step("Copied assets", null))).toBe("  ✓ Copied assets")
+    })
+})

package/test/native/redactSecrets.test.ts

@@ -0,0 +1,72 @@
+import os from "node:os"
+import path from "node:path"
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+import { expandHome, runCommand } from "../../src/native/utils.js"
+
+// The signing flow (renameAndroidProject.js) passes keystore passwords on the
+// command line, then rethrows `Failed to create signed AAB: ${error.message}`
+// and prints it. execSync's error.message carries the whole command line, so
+// the passwords have to be gone from the error itself, not just from the log.
+const STORE = "St0re-Secret-91"
+const KEY = "K3y-Secret-27"
+
+function failSigningCommand() {
+    // Fails like a wrong keystore password would, echoing a password back
+    // without its flag on both streams.
+    const command = [
+        `echo "using ${STORE}"; echo "bad key ${KEY}" >&2; exit 1;`,
+        `: ./gradlew bundleRelease`,
+        `-Pandroid.injected.signing.store.password="${STORE}"`,
+        `-Pandroid.injected.signing.key.password="${KEY}"`,
+        `-storepass "${STORE}" -keypass ${KEY}`,
+    ].join(" ")
+    try {
+        runCommand(command)
+    } catch (error) {
+        return error
+    }
+    throw new Error("expected the command to fail")
+}
+
+describe("runCommand redacts signing passwords from failures", () => {
+    afterEach(() => vi.restoreAllMocks())
+
+    it("never surfaces a password in the thrown error or the log", () => {
+        const logged: string[] = []
+        vi.spyOn(console, "error").mockImplementation((...args) => void logged.push(args.join(" ")))
+
+        const error = failSigningCommand()
+        // What renameAndroidProject.js builds from it and hands to progress.fail.
+        const wrapped = new Error(`Failed to create signed AAB: ${error.message}`)
+
+        const surfaces = [
+            error.message,
+            error.stack,
+            error.stdout,
+            error.stderr,
+            String(error.cmd ?? ""),
+            ...(error.output || []).map(String),
+            wrapped.message,
+            ...logged,
+        ].join("\n")
+
+        expect(error.message).toContain("Command failed")
+        expect(surfaces).toContain("***")
+        expect(surfaces).not.toContain(STORE)
+        expect(surfaces).not.toContain(KEY)
+    })
+})
+
+describe("expandHome", () => {
+    it("expands a leading ~ so the SDK hint's example path works", () => {
+        expect(expandHome("~/Library/Android/sdk")).toBe(path.join(os.homedir(), "Library/Android/sdk"))
+        expect(expandHome("~")).toBe(os.homedir())
+    })
+
+    it("leaves other paths alone", () => {
+        expect(expandHome("/opt/android-sdk")).toBe("/opt/android-sdk")
+        expect(expandHome("relative/~/sdk")).toBe("relative/~/sdk")
+        expect(expandHome(undefined)).toBe(undefined)
+    })
+})