catalyst-core 1.1.0 → 1.2.0-canary.2

package/test/native/androidDevices.test.ts

@@ -0,0 +1,230 @@
+import { describe, expect, it } from "vitest"
+
+import {
+    chooseAndroidTarget,
+    devServerReachPlan,
+    launchArgs,
+    parseAdbDevices,
+    reachDevServer,
+} from "../../src/native/buildAndroid/devices.js"
+import { devServerPorts } from "../../src/native/setupServer.js"
+
+const ADB_OUTPUT = [
+    "List of devices attached",
+    "emulator-5554          device product:sdk_gphone64_arm64 model:sdk_gphone64_arm64 device:emu64a transport_id:1",
+    "R5CT1234ABC            device usb:1-1 product:o1sxeea model:SM_G991B device:o1s transport_id:2",
+    "1A2B3C4D               unauthorized usb:1-2 transport_id:3",
+    "",
+].join("\n")
+
+const devices = parseAdbDevices(ADB_OUTPUT)
+const phone = { serial: "R5CT1234ABC", state: "device", emulator: false, model: "SM G991B" }
+const secondPhone = { serial: "HT7A1B2C3", state: "device", emulator: false, model: "Pixel 7" }
+const emulatorOnly = devices.filter((device) => device.emulator)
+
+async function rejection(promise: Promise<unknown>): Promise<any> {
+    try {
+        await promise
+    } catch (error) {
+        return error
+    }
+    throw new Error("expected a rejection")
+}
+
+/** A select() stand-in that records the question and answers `pick`, or the default. */
+function fakeSelect(pick?: string) {
+    const asked: Array<{ question: string; values: string[]; defaultValue: unknown }> = []
+    const select = async (question: string, choices: Array<{ value: string }>, options: any = {}) => {
+        asked.push({ question, values: choices.map((c) => c.value), defaultValue: options.defaultValue })
+        return pick ?? options.defaultValue
+    }
+    return { asked, select: select as any }
+}
+
+describe("parseAdbDevices", () => {
+    it("reads serial, state, emulator and model", () => {
+        expect(devices).toEqual([
+            { serial: "emulator-5554", state: "device", emulator: true, model: "sdk gphone64 arm64" },
+            phone,
+            { serial: "1A2B3C4D", state: "unauthorized", emulator: false, model: null },
+        ])
+        expect(parseAdbDevices("List of devices attached\n\n")).toEqual([])
+    })
+})
+
+describe("chooseAndroidTarget", () => {
+    it("uses the emulator by default, even with a phone plugged in, when there is no terminal", async () => {
+        const { asked, select } = fakeSelect()
+        expect(await chooseAndroidTarget({ devices, isTTY: false, select })).toEqual({ target: "emulator" })
+        expect(asked).toEqual([])
+    })
+
+    it("uses the emulator without asking when no phone is connected", async () => {
+        const { asked, select } = fakeSelect()
+        expect(await chooseAndroidTarget({ devices: emulatorOnly, isTTY: true, select })).toEqual({
+            target: "emulator",
+        })
+        expect(asked).toEqual([])
+    })
+
+    it("asks in a terminal when both are available, defaulting to the emulator", async () => {
+        const { asked, select } = fakeSelect()
+        expect(await chooseAndroidTarget({ devices, isTTY: true, select })).toEqual({ target: "emulator" })
+        expect(asked).toEqual([
+            { question: "Run the app on", values: ["emulator", "R5CT1234ABC"], defaultValue: "emulator" },
+        ])
+    })
+
+    it("defaults the question to the remembered phone, and returns the pick", async () => {
+        const { asked, select } = fakeSelect()
+        const target = await chooseAndroidTarget({
+            devices,
+            isTTY: true,
+            select,
+            last: { target: "device", serial: "R5CT1234ABC" },
+        })
+        expect(asked[0].defaultValue).toBe("R5CT1234ABC")
+        expect(target).toEqual({ target: "device", serial: "R5CT1234ABC", model: "SM G991B" })
+    })
+
+    it("ignores a remembered phone that is not connected", async () => {
+        const { asked, select } = fakeSelect()
+        await chooseAndroidTarget({ devices, isTTY: true, select, last: { target: "device", serial: "gone" } })
+        expect(asked[0].defaultValue).toBe("emulator")
+    })
+
+    it("--device uses the one connected phone without asking, terminal or not", async () => {
+        for (const isTTY of [true, false]) {
+            const { asked, select } = fakeSelect()
+            expect(await chooseAndroidTarget({ wantDevice: true, devices, isTTY, select, env: {} })).toEqual({
+                target: "device",
+                serial: "R5CT1234ABC",
+                model: "SM G991B",
+            })
+            expect(asked).toEqual([])
+        }
+    })
+
+    it("--device with no ready phone is ANDROID-011, naming an unauthorized one", async () => {
+        const none = await rejection(
+            chooseAndroidTarget({ wantDevice: true, devices: emulatorOnly, isTTY: true, env: {} })
+        )
+        expect(none.code).toBe("ANDROID-011")
+        const unauthorized = await rejection(
+            chooseAndroidTarget({
+                wantDevice: true,
+                devices: devices.filter((device) => device.state === "unauthorized"),
+                isTTY: false,
+                env: {},
+            })
+        )
+        expect(unauthorized.code).toBe("ANDROID-011")
+        expect(unauthorized.message).toContain("1A2B3C4D")
+    })
+
+    it("--device with several phones asks in a terminal, with the remembered one first", async () => {
+        const { asked, select } = fakeSelect("HT7A1B2C3")
+        const target = await chooseAndroidTarget({
+            wantDevice: true,
+            devices: [phone, secondPhone],
+            isTTY: true,
+            select,
+            env: {},
+            last: { target: "device", serial: "HT7A1B2C3" },
+        })
+        expect(asked[0].values).toEqual(["R5CT1234ABC", "HT7A1B2C3"])
+        expect(asked[0].defaultValue).toBe("HT7A1B2C3")
+        expect(target).toMatchObject({ target: "device", serial: "HT7A1B2C3" })
+    })
+
+    it("--device with several phones and no terminal fails with NATIVE-005 naming ANDROID_SERIAL", async () => {
+        const error = await rejection(
+            chooseAndroidTarget({ wantDevice: true, devices: [phone, secondPhone], isTTY: false, env: {} })
+        )
+        expect(error.code).toBe("NATIVE-005")
+        expect(error.hint).toContain("ANDROID_SERIAL")
+    })
+
+    it("--device honours ANDROID_SERIAL, and fails when it names no connected phone", async () => {
+        const env = { ANDROID_SERIAL: "HT7A1B2C3" }
+        expect(
+            await chooseAndroidTarget({ wantDevice: true, devices: [phone, secondPhone], isTTY: false, env })
+        ).toMatchObject({ serial: "HT7A1B2C3" })
+        const error = await rejection(
+            chooseAndroidTarget({ wantDevice: true, devices: [phone], isTTY: false, env })
+        )
+        expect(error.code).toBe("ANDROID-011")
+    })
+})
+
+describe("dev server reach (adb reverse)", () => {
+    const config = {
+        NODE_SERVER_PORT: 3005,
+        API_URL: "http://localhost:4000/api",
+        WEBVIEW_CONFIG: { port: "3005", apiBaseUrl: "http://127.0.0.1:4000" },
+    }
+
+    it("stops the app, then reverses the server, HMR and every localhost port in config", () => {
+        const ports = devServerPorts(config, { hmrPort: 24678 })
+        expect(ports).toEqual([3005, 4000, 24678])
+        expect(devServerReachPlan("emulator-5554", "com.acme.shop.debug", ports)).toEqual([
+            ["-s", "emulator-5554", "shell", "am", "force-stop", "com.acme.shop.debug"],
+            ["-s", "emulator-5554", "reverse", "tcp:3005", "tcp:3005"],
+            ["-s", "emulator-5554", "reverse", "tcp:4000", "tcp:4000"],
+            ["-s", "emulator-5554", "reverse", "tcp:24678", "tcp:24678"],
+        ])
+    })
+
+    it("runs the plan in order and tolerates an app that is not running", () => {
+        const calls: string[][] = []
+        reachDevServer(
+            (args) => {
+                calls.push(args)
+                if (args.includes("force-stop")) throw new Error("not running")
+                return ""
+            },
+            "R5CT1234ABC",
+            "com.acme.shop.debug",
+            [3005]
+        )
+        expect(calls.map((args) => args[2])).toEqual(["shell", "reverse"])
+    })
+
+    it("fails with the stage and a hint when a reverse fails", () => {
+        let error: any
+        try {
+            reachDevServer(
+                (args) => {
+                    if (args.includes("reverse")) {
+                        throw Object.assign(new Error("Command failed"), {
+                            stderr: "adb: error: cannot bind listener: Address already in use",
+                        })
+                    }
+                    return ""
+                },
+                "emulator-5554",
+                "com.acme.shop.debug",
+                [3005]
+            )
+        } catch (caught) {
+            error = caught
+        }
+        expect(error.message).toContain("Address already in use")
+        expect(error.stage).toBe("Connecting the device to the dev server")
+        expect(error.hint).toContain("reverse --list")
+    })
+
+    it("launches the app's launcher activity on that device only", () => {
+        expect(launchArgs("R5CT1234ABC", "com.acme.shop.debug")).toEqual([
+            "-s",
+            "R5CT1234ABC",
+            "shell",
+            "monkey",
+            "-p",
+            "com.acme.shop.debug",
+            "-c",
+            "android.intent.category.LAUNCHER",
+            "1",
+        ])
+    })
+})

package/test/native/androidElfAlignment.test.ts

@@ -0,0 +1,148 @@
+import zlib from "zlib"
+import { describe, expect, it } from "vitest"
+
+// The repo script that checks a built AAB/APK for 16 KB page alignment (#302).
+import {
+    checkNativeAlignment,
+    elfLoadAlignments,
+    zipEntries,
+} from "../../../../scripts/native-elf-alignment.mjs"
+
+const PT_LOAD = 1
+const PT_DYNAMIC = 2
+
+/** A tiny ELF file: just the header and program headers of the given types and alignments. */
+function elf(bits: 32 | 64, segments: Array<[type: number, align: number]>) {
+    const ehsize = bits === 64 ? 64 : 52
+    const phentsize = bits === 64 ? 56 : 32
+    const buf = Buffer.alloc(ehsize + phentsize * segments.length)
+    buf.writeUInt32BE(0x7f454c46, 0)
+    buf[4] = bits === 64 ? 2 : 1
+    buf[5] = 1 // little-endian
+    buf[6] = 1
+    if (bits === 64) {
+        buf.writeBigUInt64LE(BigInt(ehsize), 0x20)
+        buf.writeUInt16LE(phentsize, 0x36)
+        buf.writeUInt16LE(segments.length, 0x38)
+    } else {
+        buf.writeUInt32LE(ehsize, 0x1c)
+        buf.writeUInt16LE(phentsize, 0x2a)
+        buf.writeUInt16LE(segments.length, 0x2c)
+    }
+    segments.forEach(([type, align], i) => {
+        const at = ehsize + i * phentsize
+        buf.writeUInt32LE(type, at)
+        if (bits === 64) buf.writeBigUInt64LE(BigInt(align), at + 48)
+        else buf.writeUInt32LE(align, at + 28)
+    })
+    return buf
+}
+
+/** A minimal zip. `stored` entries are written uncompressed, padded so their data starts at `alignTo`. */
+function zip(files: Array<{ name: string; data: Buffer; stored?: boolean; alignTo?: number }>) {
+    const parts: Buffer[] = []
+    const central: Buffer[] = []
+    let offset = 0
+    for (const file of files) {
+        const name = Buffer.from(file.name)
+        const body = file.stored ? file.data : zlib.deflateRawSync(file.data)
+        const headerEnd = offset + 30 + name.length
+        const pad = file.alignTo ? (file.alignTo - (headerEnd % file.alignTo)) % file.alignTo : 0
+        const local = Buffer.alloc(30)
+        local.writeUInt32LE(0x04034b50, 0)
+        local.writeUInt16LE(file.stored ? 0 : 8, 8)
+        local.writeUInt32LE(body.length, 18)
+        local.writeUInt32LE(file.data.length, 22)
+        local.writeUInt16LE(name.length, 26)
+        local.writeUInt16LE(pad, 28)
+        const entry = Buffer.alloc(46)
+        entry.writeUInt32LE(0x02014b50, 0)
+        entry.writeUInt16LE(file.stored ? 0 : 8, 10)
+        entry.writeUInt32LE(body.length, 20)
+        entry.writeUInt32LE(file.data.length, 24)
+        entry.writeUInt16LE(name.length, 28)
+        entry.writeUInt32LE(offset, 42)
+        central.push(entry, name)
+        parts.push(local, name, Buffer.alloc(pad), body)
+        offset += 30 + name.length + pad + body.length
+    }
+    const cd = Buffer.concat(central)
+    const end = Buffer.alloc(22)
+    end.writeUInt32LE(0x06054b50, 0)
+    end.writeUInt16LE(files.length, 8)
+    end.writeUInt16LE(files.length, 10)
+    end.writeUInt32LE(cd.length, 12)
+    end.writeUInt32LE(offset, 16)
+    return Buffer.concat([...parts, cd, end])
+}
+
+const aligned64 = elf(64, [
+    [PT_LOAD, 0x4000],
+    [PT_DYNAMIC, 8],
+    [PT_LOAD, 0x4000],
+])
+const unaligned64 = elf(64, [
+    [PT_LOAD, 0x4000],
+    [PT_LOAD, 0x1000],
+])
+const unaligned32 = elf(32, [[PT_LOAD, 0x1000]])
+
+describe("ELF LOAD alignment", () => {
+    it("reads p_align of LOAD segments only, for 64- and 32-bit ELF", () => {
+        expect(elfLoadAlignments(aligned64)).toEqual({ bits: 64, aligns: [0x4000, 0x4000] })
+        expect(elfLoadAlignments(unaligned32)).toEqual({ bits: 32, aligns: [0x1000] })
+        expect(() => elfLoadAlignments(Buffer.from("not an elf file, just some text here......................"))).toThrow(
+            /not an ELF/
+        )
+    })
+
+    it("reads stored and deflated zip entries", () => {
+        const entries = zipEntries(
+            zip([
+                { name: "a.txt", data: Buffer.from("hello") },
+                { name: "b.bin", data: Buffer.from("world"), stored: true },
+            ])
+        )
+        expect(entries.map((entry) => [entry.name, entry.method, entry.read().toString()])).toEqual([
+            ["a.txt", 8, "hello"],
+            ["b.bin", 0, "world"],
+        ])
+    })
+})
+
+describe("checkNativeAlignment", () => {
+    it("passes an AAB whose 64-bit libs are 16 KB aligned, reporting but not failing 4 KB 32-bit libs", () => {
+        const aab = zip([
+            { name: "base/lib/arm64-v8a/libgood.so", data: aligned64 },
+            { name: "base/lib/armeabi-v7a/libold.so", data: unaligned32 },
+            { name: "base/assets/notalib.so.txt", data: Buffer.from("x") },
+        ])
+        const result = checkNativeAlignment(aab)
+        expect(result.failures).toEqual([])
+        expect(result.libs.map((lib) => [lib.name, lib.ok, lib.required])).toEqual([
+            ["base/lib/arm64-v8a/libgood.so", true, true],
+            ["base/lib/armeabi-v7a/libold.so", false, false],
+        ])
+    })
+
+    it("fails a 64-bit lib with any LOAD segment below 0x4000", () => {
+        const result = checkNativeAlignment(
+            zip([{ name: "base/lib/x86_64/libimage_processing_util_jni.so", data: unaligned64 }])
+        )
+        expect(result.failures).toEqual([
+            "base/lib/x86_64/libimage_processing_util_jni.so: LOAD segment aligned to 0x1000 (needs 0x4000)",
+        ])
+    })
+
+    it("in an APK, fails an uncompressed 64-bit lib that is not on a 16 KB zip boundary", () => {
+        const misplaced = zip([{ name: "lib/arm64-v8a/libgood.so", data: aligned64, stored: true, alignTo: 4096 }])
+        const placed = zip([{ name: "lib/arm64-v8a/libgood.so", data: aligned64, stored: true, alignTo: 0x4000 }])
+        expect(zipEntries(misplaced)[0].dataOffset).toBe(4096)
+        expect(checkNativeAlignment(misplaced, { apk: true }).failures).toEqual([
+            "lib/arm64-v8a/libgood.so: stored uncompressed at zip offset 4096, not on a 16 KB boundary",
+        ])
+        expect(checkNativeAlignment(placed, { apk: true }).failures).toEqual([])
+        // An AAB is aligned by bundletool later, so its zip offsets are not checked.
+        expect(checkNativeAlignment(misplaced).failures).toEqual([])
+    })
+})