@autifyhq/aximo-cli 0.4.0 → 0.6.0

package/dist/commands/mobile/install.test.js

@@ -0,0 +1,104 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runMobileInstall } from "./install.js";
+const ONE_ANDROID = "List of devices attached\nR1 device\n";
+const ONE_IOS = `${JSON.stringify({ udid: "00008030-ABC", name: "iPhone", type: "device" })}\n`;
+let dir;
+let apkPath;
+let ipaPath;
+let txtPath;
+beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "aximo-mob-install-"));
+    apkPath = join(dir, "app.apk");
+    ipaPath = join(dir, "app.ipa");
+    txtPath = join(dir, "app.txt");
+    for (const p of [apkPath, ipaPath, txtPath])
+        writeFileSync(p, "x");
+});
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+/** Mock adb/idb: serve device discovery and capture the `install` invocation. */
+function execWith(opts = {}) {
+    let captured = { file: "", args: [] };
+    const exec = async (file, args) => {
+        if (file === "adb" && args[0] === "devices") {
+            return { stdout: Buffer.from(ONE_ANDROID), stderr: "" };
+        }
+        if (file === "idb" && args[0] === "list-targets") {
+            return { stdout: Buffer.from(ONE_IOS), stderr: "" };
+        }
+        if ((file === "adb" || file === "idb") && args.includes("install")) {
+            captured = { file, args };
+            if (opts.throwMsg)
+                throw new Error(opts.throwMsg);
+            return { stdout: Buffer.from(opts.out ?? "Success"), stderr: "" };
+        }
+        throw new Error(`unexpected exec: ${file} ${args.join(" ")}`);
+    };
+    return { exec, install: () => captured };
+}
+describe("runMobileInstall", () => {
+    it("requires --app", async () => {
+        const { exec } = execWith();
+        const res = await runMobileInstall({}, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.code).toBe("validation_error");
+    });
+    it("errors when the app file is missing", async () => {
+        const { exec } = execWith();
+        const res = await runMobileInstall({ app: "definitely-not-here-xyz.apk" }, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.message).toMatch(/not found/i);
+    });
+    it("errors when the platform cannot be inferred", async () => {
+        const { exec } = execWith();
+        const res = await runMobileInstall({ app: txtPath }, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.message).toMatch(/determine platform/i);
+    });
+    it("installs an .apk via `adb -s <serial> install -r`", async () => {
+        const { exec, install } = execWith({ out: "Performing Streamed Install\nSuccess" });
+        const res = await runMobileInstall({ app: apkPath }, exec);
+        expect(res.ok).toBe(true);
+        if (res.ok) {
+            expect(res.data.platform).toBe("android");
+            expect(res.data.serial).toBe("R1");
+            expect(res.data.udid).toBeUndefined();
+            expect(res.data.output).toContain("Success");
+        }
+        expect(install().file).toBe("adb");
+        expect(install().args.slice(0, 2)).toEqual(["-s", "R1"]);
+        expect(install().args).toEqual(expect.arrayContaining(["install", "-r"]));
+    });
+    it("installs an .ipa via `idb install --udid <udid>`", async () => {
+        const { exec, install } = execWith({ out: "Installed" });
+        const res = await runMobileInstall({ app: ipaPath }, exec);
+        expect(res.ok).toBe(true);
+        if (res.ok) {
+            expect(res.data.platform).toBe("ios");
+            expect(res.data.udid).toBe("00008030-ABC");
+            expect(res.data.serial).toBeUndefined();
+        }
+        expect(install().file).toBe("idb");
+        expect(install().args).toEqual(["install", "--udid", "00008030-ABC", ipaPath]);
+    });
+    it("honors an explicit --platform override", async () => {
+        const { exec, install } = execWith();
+        const res = await runMobileInstall({ app: txtPath, platform: "android" }, exec);
+        expect(res.ok).toBe(true);
+        expect(install().file).toBe("adb");
+    });
+    it("maps an install failure to an error envelope", async () => {
+        const { exec } = execWith({ throwMsg: "adb: failed to install: INSTALL_FAILED_INVALID_APK" });
+        const res = await runMobileInstall({ app: apkPath }, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok) {
+            expect(res.error.code).toBe("api_error");
+            expect(res.error.message).toMatch(/INSTALL_FAILED/);
+        }
+    });
+});

package/dist/commands/mobile/list.d.ts

@@ -0,0 +1,10 @@
+import type { Envelope } from "../../types.js";
+import { type AndroidDevice, type IosPhysicalDevice } from "../../mobile-control/devices.js";
+import type { ExecFn } from "../../mobile-control/exec.js";
+export interface MobileListResult {
+    androidDevices: AndroidDevice[];
+    iosDevices: IosPhysicalDevice[];
+}
+export declare function runMobileList(exec?: ExecFn): Promise<Envelope<MobileListResult>>;
+declare const _default: import("citty").CommandDef<{}>;
+export default _default;

package/dist/commands/mobile/list.js

@@ -0,0 +1,30 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult } from "../../output.js";
+import { listAndroidDevices, listIosPhysicalDevices, } from "../../mobile-control/devices.js";
+async function safe(fn, fallback) {
+    try {
+        return await fn();
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function runMobileList(exec) {
+    const [allAndroid, iosDevices] = await Promise.all([
+        safe(() => listAndroidDevices(exec), []),
+        safe(() => listIosPhysicalDevices(exec), []),
+    ]);
+    // Physical phones only: drop emulator serials.
+    const androidDevices = allAndroid.filter((d) => !d.serial.startsWith("emulator-"));
+    return formatSuccess({ androidDevices, iosDevices });
+}
+export default defineCommand({
+    meta: {
+        name: "list",
+        description: "List physically-connected phones (Android via adb, iOS via idb)",
+    },
+    args: {},
+    async run() {
+        printResult(await runMobileList());
+    },
+});

package/dist/commands/mobile/paths.d.ts

@@ -0,0 +1,14 @@
+export type MobilePlatform = "ios" | "android";
+export interface MobileDeviceConfig {
+    deviceId: string;
+    deviceToken: string;
+    name: string;
+    platform: MobilePlatform;
+    /** udid for iOS, adb serial for Android. */
+    target: string;
+}
+export declare function getMobileDevicesDir(): string;
+export declare function getMobileDeviceConfigPath(deviceId: string): string;
+export declare function writeMobileDeviceConfig(config: MobileDeviceConfig): string;
+export declare function readMobileDeviceConfig(deviceId: string): MobileDeviceConfig | null;
+export declare function listMobileDeviceConfigs(): MobileDeviceConfig[];

package/dist/commands/mobile/paths.js

@@ -0,0 +1,71 @@
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { getAximoDir } from "../device/paths.js";
+export function getMobileDevicesDir() {
+    return join(getAximoDir(), "mobile-devices");
+}
+export function getMobileDeviceConfigPath(deviceId) {
+    return join(getMobileDevicesDir(), `${deviceId}.json`);
+}
+export function writeMobileDeviceConfig(config) {
+    const dir = getMobileDevicesDir();
+    mkdirSync(dir, { recursive: true });
+    const path = getMobileDeviceConfigPath(config.deviceId);
+    writeFileSync(path, JSON.stringify(config, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // chmod may fail on Windows; file-level ACLs apply instead.
+    }
+    return path;
+}
+function parseConfig(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const c = raw;
+    if (typeof c.deviceId !== "string" ||
+        typeof c.deviceToken !== "string" ||
+        typeof c.name !== "string" ||
+        (c.platform !== "ios" && c.platform !== "android") ||
+        typeof c.target !== "string") {
+        return null;
+    }
+    return {
+        deviceId: c.deviceId,
+        deviceToken: c.deviceToken,
+        name: c.name,
+        platform: c.platform,
+        target: c.target,
+    };
+}
+export function readMobileDeviceConfig(deviceId) {
+    const path = getMobileDeviceConfigPath(deviceId);
+    if (!existsSync(path))
+        return null;
+    try {
+        return parseConfig(JSON.parse(readFileSync(path, "utf-8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function listMobileDeviceConfigs() {
+    const dir = getMobileDevicesDir();
+    if (!existsSync(dir))
+        return [];
+    const result = [];
+    for (const file of readdirSync(dir)) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const parsed = parseConfig(JSON.parse(readFileSync(join(dir, file), "utf-8")));
+            if (parsed)
+                result.push(parsed);
+        }
+        catch {
+            // skip unreadable entries
+        }
+    }
+    return result;
+}

package/dist/commands/mobile/register-core.d.ts

@@ -0,0 +1,19 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+import { type MobilePlatform } from "./paths.js";
+export interface MobileRegisterResult {
+    deviceId: string;
+    name: string;
+    platform: MobilePlatform;
+    target: string;
+    configPath: string;
+}
+export interface MobileRegisterOptions {
+    name: string;
+    platform: MobilePlatform;
+    target: string;
+    os?: string;
+}
+/** Shared registration: POST /api/devices/register and persist the config. */
+export declare function registerMobileDevice(options: MobileRegisterOptions, deps?: ClientDeps): Promise<Envelope<MobileRegisterResult>>;
+export declare function parsePlatformArg(value: string | undefined): MobilePlatform | null;

package/dist/commands/mobile/register-core.js

@@ -0,0 +1,46 @@
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatError, formatSuccess } from "../../output.js";
+import { writeMobileDeviceConfig } from "./paths.js";
+/** Shared registration: POST /api/devices/register and persist the config. */
+export async function registerMobileDevice(options, deps) {
+    if (!options.name) {
+        return formatError("validation_error", "Device name is required (--name).", false);
+    }
+    if (!options.target) {
+        return formatError("validation_error", options.platform === "ios"
+            ? "Could not resolve a device target (--udid)."
+            : "Could not resolve a device target (--serial).", false);
+    }
+    try {
+        const body = {
+            name: options.name,
+            platform: options.platform,
+        };
+        if (options.os)
+            body["os"] = options.os;
+        const res = await request("/api/devices/register", { method: "POST", body }, deps ?? {});
+        const configPath = writeMobileDeviceConfig({
+            deviceId: res.deviceId,
+            deviceToken: res.deviceToken,
+            name: options.name,
+            platform: options.platform,
+            target: options.target,
+        });
+        return formatSuccess({
+            deviceId: res.deviceId,
+            name: options.name,
+            platform: options.platform,
+            target: options.target,
+            configPath,
+        });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export function parsePlatformArg(value) {
+    if (value === "ios" || value === "android")
+        return value;
+    return null;
+}

package/dist/commands/mobile/register.d.ts

@@ -0,0 +1,37 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+import type { ExecFn } from "../../mobile-control/exec.js";
+import { type MobileRegisterResult } from "./register-core.js";
+export interface MobileRegisterCmdOptions {
+    name: string;
+    platform: string;
+    serial?: string | undefined;
+    udid?: string | undefined;
+    os?: string | undefined;
+}
+export declare function runMobileRegister(options: MobileRegisterCmdOptions, deps?: ClientDeps, exec?: ExecFn): Promise<Envelope<MobileRegisterResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly name: {
+        readonly type: "string";
+        readonly description: "Device name";
+        readonly required: true;
+    };
+    readonly platform: {
+        readonly type: "string";
+        readonly description: "Device platform (`android` or `ios`)";
+        readonly default: "android";
+    };
+    readonly serial: {
+        readonly type: "string";
+        readonly description: "Android adb serial (defaults to the connected one)";
+    };
+    readonly udid: {
+        readonly type: "string";
+        readonly description: "iOS device udid (defaults to the connected one)";
+    };
+    readonly os: {
+        readonly type: "string";
+        readonly description: "Optional OS version label";
+    };
+}>;
+export default _default;

package/dist/commands/mobile/register.js

@@ -0,0 +1,57 @@
+import { defineCommand } from "citty";
+import {} from "../../client.js";
+import { formatError, printResult } from "../../output.js";
+import { resolveAndroidSerial, resolveIosUdid } from "../../mobile-control/devices.js";
+import { parsePlatformArg, registerMobileDevice, } from "./register-core.js";
+export async function runMobileRegister(options, deps, exec) {
+    const platform = parsePlatformArg(options.platform);
+    if (!platform) {
+        return formatError("validation_error", "Invalid --platform; expected `android` or `ios`.", false);
+    }
+    if (!options.name) {
+        return formatError("validation_error", "Device name is required (--name).", false);
+    }
+    // Resolve the device target: an adb serial for Android, a udid for iOS.
+    let target;
+    try {
+        target =
+            platform === "ios"
+                ? await resolveIosUdid(options.udid, exec)
+                : await resolveAndroidSerial(options.serial, exec);
+    }
+    catch (err) {
+        return formatError("validation_error", err instanceof Error ? err.message : String(err), false);
+    }
+    return registerMobileDevice({
+        name: options.name,
+        platform,
+        target,
+        ...(options.os ? { os: options.os } : {}),
+    }, deps);
+}
+export default defineCommand({
+    meta: {
+        name: "register",
+        description: "Register a physically-connected Android phone or iPhone as an Aximo device",
+    },
+    args: {
+        name: { type: "string", description: "Device name", required: true },
+        platform: {
+            type: "string",
+            description: "Device platform (`android` or `ios`)",
+            default: "android",
+        },
+        serial: { type: "string", description: "Android adb serial (defaults to the connected one)" },
+        udid: { type: "string", description: "iOS device udid (defaults to the connected one)" },
+        os: { type: "string", description: "Optional OS version label" },
+    },
+    async run({ args }) {
+        printResult(await runMobileRegister({
+            name: args.name,
+            platform: args.platform,
+            serial: args.serial,
+            udid: args.udid,
+            os: args.os,
+        }));
+    },
+});

package/dist/commands/mobile/register.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/mobile/register.test.js

@@ -0,0 +1,91 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runMobileRegister } from "./register.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-mob-reg-"));
+    process.env["AXIMO_HOME"] = tempHome;
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterAll(() => {
+    delete process.env["AXIMO_HOME"];
+    server.close();
+    rmSync(tempHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    mkdirSync(tempHome, { recursive: true });
+});
+afterEach(() => server.resetHandlers());
+const oneAndroidDevice = async () => ({
+    stdout: Buffer.from("List of devices attached\nR58M12345  device model:Pixel_7\n"),
+    stderr: "",
+});
+const oneIosDevice = async (file, args) => {
+    if (file === "idb" && args[0] === "list-targets") {
+        return {
+            stdout: Buffer.from(`${JSON.stringify({
+                udid: "00008030-ABCDEF",
+                name: "Abdul's iPhone",
+                type: "device",
+                state: "connected",
+            })}\n`),
+            stderr: "",
+        };
+    }
+    throw new Error(`unexpected exec: ${file} ${args.join(" ")}`);
+};
+describe("runMobileRegister", () => {
+    it("posts the resolved android serial and writes config", async () => {
+        let body;
+        server.use(http.post(`${TEST_BASE_URL}/api/devices/register`, async ({ request }) => {
+            body = (await request.json());
+            return HttpResponse.json({ deviceId: "dev-9", deviceToken: "tok-9" }, { status: 201 });
+        }));
+        const result = await runMobileRegister({ name: "My Pixel", platform: "android" }, undefined, oneAndroidDevice);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(body).toMatchObject({
+            name: "My Pixel",
+            platform: "android",
+        });
+        expect(body).not.toHaveProperty("category");
+        expect(result.data.target).toBe("R58M12345");
+        const configPath = join(tempHome, "mobile-devices", "dev-9.json");
+        expect(existsSync(configPath)).toBe(true);
+        const saved = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(saved).toMatchObject({ platform: "android", target: "R58M12345" });
+        expect(saved).not.toHaveProperty("category");
+    });
+    it("posts the resolved iOS udid and writes config", async () => {
+        let body;
+        server.use(http.post(`${TEST_BASE_URL}/api/devices/register`, async ({ request }) => {
+            body = (await request.json());
+            return HttpResponse.json({ deviceId: "dev-ios", deviceToken: "tok-ios" }, { status: 201 });
+        }));
+        const result = await runMobileRegister({ name: "iPhone", platform: "ios" }, undefined, oneIosDevice);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(body).toMatchObject({ name: "iPhone", platform: "ios" });
+        expect(result.data.target).toBe("00008030-ABCDEF");
+        const configPath = join(tempHome, "mobile-devices", "dev-ios.json");
+        expect(existsSync(configPath)).toBe(true);
+        const saved = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(saved).toMatchObject({ platform: "ios", target: "00008030-ABCDEF" });
+    });
+    it("rejects an unknown platform", async () => {
+        const result = await runMobileRegister({ name: "x", platform: "windows" });
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("validation_error");
+            expect(result.error.message).toContain("Invalid --platform");
+        }
+    });
+});

package/dist/commands/mobile/setup.d.ts

@@ -0,0 +1,27 @@
+import type { Envelope } from "../../types.js";
+import { type MobileDoctorReport } from "./doctor.js";
+export interface DriverSetupResult {
+    driver: string;
+    alreadyInstalled: boolean;
+}
+export interface SetupResult {
+    appiumHome: string;
+    drivers: DriverSetupResult[];
+}
+export type DriverInstaller = (driver: string, appiumHome: string) => Promise<void>;
+export interface RunMobileSetupOptions {
+    platform?: "ios" | "android" | undefined;
+    install?: DriverInstaller;
+    appiumHome?: string;
+    doctor?: (options: {
+        platform?: "ios" | "android" | undefined;
+    }) => Promise<Envelope<MobileDoctorReport>>;
+}
+export declare function runMobileSetup(options?: RunMobileSetupOptions): Promise<Envelope<SetupResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly platform: {
+        readonly type: "string";
+        readonly description: "Limit to ios | android driver";
+    };
+}>;
+export default _default;

package/dist/commands/mobile/setup.js

@@ -0,0 +1,100 @@
+import { defineCommand } from "citty";
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { formatError, formatSuccess, printResult } from "../../output.js";
+import { getAppiumHome } from "../../mobile-control/appium-server.js";
+import { runMobileDoctor } from "./doctor.js";
+const DRIVER_PACKAGE = {
+    uiautomator2: "appium-uiautomator2-driver",
+    xcuitest: "appium-xcuitest-driver",
+};
+function resolveAppiumBin() {
+    const require = createRequire(import.meta.url);
+    return require.resolve("appium");
+}
+const defaultInstaller = (driver, appiumHome) => new Promise((resolve, reject) => {
+    execFile(process.execPath, [resolveAppiumBin(), "driver", "install", driver], { env: { ...process.env, APPIUM_HOME: appiumHome }, maxBuffer: 16 * 1024 * 1024 }, (error, _stdout, stderr) => {
+        if (error) {
+            reject(new Error(stderr?.toString().trim() || error.message));
+            return;
+        }
+        resolve();
+    });
+});
+function isInstalled(driver, appiumHome) {
+    const pkg = DRIVER_PACKAGE[driver];
+    return pkg ? existsSync(join(appiumHome, "node_modules", pkg)) : false;
+}
+// After installing drivers, tell the user what is still required to drive a real
+// device (adb / Xcode / Developer Mode) rather than implying setup is complete.
+function printNextSteps(checks) {
+    const blockers = checks.filter((c) => c.status === "fail" || c.status === "warn");
+    const notes = checks.filter((c) => c.status === "info");
+    if (blockers.length === 0) {
+        console.error("\nAll required prerequisites are satisfied.");
+    }
+    else {
+        console.error("\nDrivers installed, but you still need to set up:");
+        for (const c of blockers) {
+            console.error(`  - ${c.message}`);
+            if (c.hint)
+                console.error(`      ${c.hint}`);
+        }
+    }
+    for (const c of notes) {
+        console.error(`\nNote: ${c.message}`);
+        if (c.hint)
+            console.error(`      ${c.hint}`);
+    }
+    console.error("\nNext: aximo mobile register --platform android  ->  aximo mobile connect  (recheck: aximo mobile doctor)");
+}
+export async function runMobileSetup(options = {}) {
+    const appiumHome = options.appiumHome ?? getAppiumHome();
+    const install = options.install ?? defaultInstaller;
+    mkdirSync(appiumHome, { recursive: true });
+    const drivers = [];
+    if (options.platform !== "ios")
+        drivers.push("uiautomator2");
+    if (options.platform !== "android")
+        drivers.push("xcuitest");
+    const results = [];
+    for (const driver of drivers) {
+        if (isInstalled(driver, appiumHome)) {
+            console.error(`Appium driver "${driver}" already installed.`);
+            results.push({ driver, alreadyInstalled: true });
+            continue;
+        }
+        console.error(`Installing Appium driver "${driver}"...`);
+        try {
+            await install(driver, appiumHome);
+        }
+        catch (err) {
+            return formatError("api_error", `Failed to install Appium driver "${driver}": ${err instanceof Error ? err.message : String(err)}`, true);
+        }
+        console.error(`Installed Appium driver "${driver}".`);
+        results.push({ driver, alreadyInstalled: false });
+    }
+    // Surface remaining prerequisites as concise guidance; `doctor` owns the full report.
+    const runDoctor = options.doctor ?? runMobileDoctor;
+    const report = await runDoctor({ platform: options.platform });
+    printNextSteps(report.ok ? report.data.checks : []);
+    return formatSuccess({ appiumHome, drivers: results });
+}
+export default defineCommand({
+    meta: {
+        name: "setup",
+        description: "Install the Appium drivers used to drive registered phones",
+    },
+    args: {
+        platform: { type: "string", description: "Limit to ios | android driver" },
+    },
+    async run({ args }) {
+        const options = {};
+        if (args.platform === "ios" || args.platform === "android")
+            options.platform = args.platform;
+        const result = await runMobileSetup(options);
+        printResult(result);
+    },
+});

package/dist/commands/mobile/setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/mobile/setup.test.js

@@ -0,0 +1,49 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runMobileSetup } from "./setup.js";
+function fakeDoctor(checks) {
+    return async () => ({
+        ok: true,
+        data: { checks, summary: { pass: 0, warn: 0, fail: 0, info: 0 } },
+    });
+}
+describe("runMobileSetup", () => {
+    it("installs both drivers and runs the prerequisite check", async () => {
+        const appiumHome = mkdtempSync(join(tmpdir(), "aximo-setup-"));
+        const installed = [];
+        let doctorCalled = false;
+        const res = await runMobileSetup({
+            appiumHome,
+            install: async (driver) => {
+                installed.push(driver);
+            },
+            doctor: async () => {
+                doctorCalled = true;
+                return fakeDoctor([])();
+            },
+        });
+        expect(installed).toEqual(["uiautomator2", "xcuitest"]);
+        expect(doctorCalled).toBe(true);
+        expect(res.ok).toBe(true);
+        if (res.ok) {
+            expect(res.data.drivers.map((d) => d.driver)).toEqual(["uiautomator2", "xcuitest"]);
+            // checks are surfaced as guidance, not embedded in setup's JSON result
+            expect(res.data).not.toHaveProperty("checks");
+        }
+    });
+    it("limits to one driver with a platform filter", async () => {
+        const appiumHome = mkdtempSync(join(tmpdir(), "aximo-setup-"));
+        const installed = [];
+        await runMobileSetup({
+            appiumHome,
+            platform: "android",
+            install: async (driver) => {
+                installed.push(driver);
+            },
+            doctor: fakeDoctor([]),
+        });
+        expect(installed).toEqual(["uiautomator2"]);
+    });
+});