@specific.dev/spectest 0.89.1 → 0.90.1

package/dist/android-step.d.ts

@@ -0,0 +1,22 @@
+/** Recorded semantics, independent of Appium's wire selectors and display titles. */
+export interface AndroidTarget {
+    kind: "text" | "id" | "accessibility" | "class" | "xpath" | "custom";
+    value: string;
+    /** Original strategy for a custom locator; never interpreted as display text. */
+    strategy?: string;
+}
+export interface AndroidStepDetails {
+    device: string;
+    action: "tap" | "fill" | "text" | "visible" | "wait" | "swipe" | "back" | "source" | "screenshot" | "execute";
+    target?: AndroidTarget;
+    point?: {
+        x: number;
+        y: number;
+    };
+    direction?: "up" | "down" | "left" | "right";
+    state?: "visible" | "hidden";
+    command?: string;
+}
+export declare function androidTarget(using: string, value: string): AndroidTarget;
+export declare function androidTargetLabel(target: AndroidTarget): string;
+export declare function androidStepTitle(step: AndroidStepDetails): string;

package/dist/android-step.js

@@ -0,0 +1,78 @@
+export function androidTarget(using, value) {
+    const kind = new Map([
+        ["id", "id"],
+        ["accessibility id", "accessibility"],
+        ["class name", "class"],
+        ["xpath", "xpath"],
+    ]).get(using);
+    return kind ? { kind, value } : { kind: "custom", value, strategy: using };
+}
+export function androidTargetLabel(target) {
+    const quoted = JSON.stringify(target.value);
+    switch (target.kind) {
+        case "text":
+            return `text ${quoted}`;
+        case "id":
+            return `id ${quoted}`;
+        case "accessibility":
+            return `accessibility label ${quoted}`;
+        case "xpath":
+            return `XPath ${quoted}`;
+        case "custom":
+            return "custom selector";
+        case "class": {
+            const classes = {
+                "android.widget.EditText": "text field",
+                "android.widget.Button": "button",
+                "android.widget.TextView": "text view",
+                "android.widget.CheckBox": "checkbox",
+                "android.widget.Switch": "switch",
+                "android.widget.ImageView": "image",
+                "android.widget.ScrollView": "scroll view",
+                "androidx.recyclerview.widget.RecyclerView": "list",
+            };
+            return Object.hasOwn(classes, target.value)
+                ? classes[target.value]
+                : `class ${quoted}`;
+        }
+    }
+}
+export function androidStepTitle(step) {
+    const target = step.target ? androidTargetLabel(step.target) : "element";
+    let label;
+    switch (step.action) {
+        case "tap":
+            label = step.point
+                ? `tap (${step.point.x}, ${step.point.y})`
+                : `tap ${target}`;
+            break;
+        case "fill":
+            label = `fill ${target}`;
+            break;
+        case "text":
+            label = `read text from ${target}`;
+            break;
+        case "visible":
+            label = `check ${target} is visible`;
+            break;
+        case "wait":
+            label = `wait for ${target} to be ${step.state ?? "visible"}`;
+            break;
+        case "swipe":
+            label = `swipe ${step.direction}`;
+            break;
+        case "back":
+            label = "go back";
+            break;
+        case "source":
+            label = "read screen structure";
+            break;
+        case "screenshot":
+            label = "take screenshot";
+            break;
+        case "execute":
+            label = `run command ${JSON.stringify(step.command)}`;
+            break;
+    }
+    return `${step.device}: ${label}`;
+}

package/dist/android.d.ts

@@ -0,0 +1,84 @@
+import { type Wrapped } from "./inspect.js";
+export interface AndroidRecordingOptions {
+    /** Maximum dimension of the video, default 1280. */
+    maxSize?: number;
+    /** Maximum frame rate, default 15. Static screens produce few frames. */
+    maxFps?: number;
+    /** H.264 bitrate target in bits/second, default 2,000,000. */
+    bitRate?: number;
+}
+export declare const ANDROID_APP: unique symbol;
+export interface AndroidApp {
+    readonly [ANDROID_APP]: true;
+    readonly name: string;
+    readonly endpoint: string;
+    readonly recorderEndpoint: string;
+    readonly serial: string;
+    readonly package: string;
+    readonly recording: false | AndroidRecordingOptions;
+    readonly showTouches?: boolean;
+}
+export declare function androidApp(options: Omit<AndroidApp, typeof ANDROID_APP>): AndroidApp;
+export declare function isAndroidApp(value: unknown): value is AndroidApp;
+export declare class AppiumError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface AndroidElement {
+    tap(): Promise<void>;
+    fill(text: string): Promise<void>;
+    text(): Promise<Wrapped<string>>;
+    isDisplayed(): Promise<Wrapped<boolean>>;
+    waitFor(options?: {
+        state?: "visible" | "hidden";
+        timeoutMs?: number;
+    }): Promise<void>;
+}
+export interface Android {
+    getByAccessibilityId(id: string): AndroidElement;
+    getById(resourceId: string): AndroidElement;
+    getByText(text: string): AndroidElement;
+    /** Appium selector, e.g. -android uiautomator or xpath. */
+    locator(using: string, value: string): AndroidElement;
+    tap(x: number, y: number): Promise<void>;
+    swipe(direction: "up" | "down" | "left" | "right"): Promise<void>;
+    back(): Promise<void>;
+    pageSource(): Promise<Wrapped<string>>;
+    /** PNG bytes. */
+    screenshot(): Promise<Uint8Array>;
+    /** Appium extension command, e.g. mobile: getDeviceInfo. */
+    execute<T = unknown>(script: string, args?: Record<string, unknown>): Promise<Wrapped<T>>;
+}
+export interface AndroidTap {
+    /** Milliseconds from the case start, in the same clock as the video manifest. */
+    offsetMs: number;
+    /** Normalized screen coordinates, independent of encoding resolution. */
+    x: number;
+    y: number;
+}
+export interface AndroidRecording {
+    id: string;
+    name: string;
+    package: string;
+    openedAtMs: number;
+    closedAtMs: number;
+    mediaDurationMs: number;
+    width: number;
+    height: number;
+    bytes: number;
+    taps?: AndroidTap[];
+    error?: string;
+}
+/** A case owns capture and handle lifetime; the Android/Appium processes outlive it. */
+export declare function androidScope(caseId: string, testStartedAt: number, options?: {
+    record?: boolean;
+}): {
+    begin: (apps?: Iterable<AndroidApp>) => Promise<void>;
+    open: (app: AndroidApp) => Promise<Android>;
+    finish: () => Promise<AndroidRecording[]>;
+    deactivate: () => void;
+};
+export declare function androidRecordingChunk(id: string, offset: unknown, limit: unknown): Promise<unknown>;
+export declare function releaseAndroidRecording(id: string): Promise<{
+    released: boolean;
+}>;

package/dist/android.js

@@ -0,0 +1,360 @@
+import { createHash } from "node:crypto";
+import { rawFetch } from "./harness/raw-fetch.js";
+import { recordStep, reserveEvent } from "./recorder.js";
+import { wrap } from "./inspect.js";
+import { androidStepTitle, androidTarget, androidTargetLabel } from "./android-step.js";
+export const ANDROID_APP = Symbol.for("spectest.androidApp");
+export function androidApp(options) {
+    return { ...options, [ANDROID_APP]: true };
+}
+export function isAndroidApp(value) {
+    return !!value && typeof value === "object" && value[ANDROID_APP] === true;
+}
+export class AppiumError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AppiumError";
+    }
+}
+async function request(url, method = "GET", body) {
+    const response = await rawFetch(url, {
+        method,
+        ...(body === undefined
+            ? {}
+            : { headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }),
+        signal: AbortSignal.timeout(120000),
+    });
+    const data = (await response.json());
+    if (!response.ok || data.value?.error || data.error)
+        throw new AppiumError(data.value?.error ?? "unknown error", data.value?.message ?? data.error ?? `Android request failed (${response.status})`);
+    return ("value" in data ? data.value : data);
+}
+// Both the Appium session and this registry are preserved by a VM snapshot.
+// Never reset/relaunch the app or delete its session at a case boundary.
+const sessions = new Map();
+async function session(app) {
+    const key = JSON.stringify([app.endpoint, app.serial, app.package]);
+    let pending = sessions.get(key);
+    if (!pending) {
+        pending = request(`${app.endpoint}/session`, "POST", {
+            capabilities: {
+                alwaysMatch: {
+                    platformName: "Android",
+                    "appium:automationName": "UiAutomator2",
+                    "appium:udid": app.serial,
+                    "appium:appPackage": app.package,
+                    "appium:noReset": true,
+                    "appium:autoLaunch": false,
+                    "appium:dontStopAppOnReset": true,
+                    "appium:newCommandTimeout": 0,
+                },
+            },
+        })
+            .then((result) => {
+            if (!result.sessionId)
+                throw new Error("Appium returned no session id");
+            return result.sessionId;
+        })
+            .catch((error) => {
+            sessions.delete(key);
+            throw error;
+        });
+        sessions.set(key, pending);
+    }
+    return pending;
+}
+const parked = new Map();
+let epoch = 0;
+/** A case owns capture and handle lifetime; the Android/Appium processes outlive it. */
+export function androidScope(caseId, testStartedAt, options = {}) {
+    let active = true;
+    const captures = new Map();
+    const handles = new Map();
+    const taps = new Map();
+    const assertActive = () => {
+        if (!active)
+            throw new Error("This Android handle belongs to a finished test");
+    };
+    async function capture(app) {
+        assertActive();
+        if (app.recording === false || options.record === false)
+            return;
+        let pending = captures.get(app.name);
+        if (!pending) {
+            if (captures.size >= 8)
+                throw new Error("A case can record at most eight Android devices");
+            const id = createHash("sha256").update(`${caseId}:${app.name}:${++epoch}`).digest("hex");
+            pending = request(`${app.recorderEndpoint}/recordings`, "POST", {
+                id,
+                ...app.recording,
+            }).then((result) => ({
+                app,
+                id,
+                openedAtMs: Math.max(0, result.startedAtMs - testStartedAt),
+            }));
+            captures.set(app.name, pending);
+        }
+        await pending;
+    }
+    async function begin(apps = []) {
+        assertActive();
+        // Previous artifacts were fetched before the VM was handed off. Forked
+        // children can discard their inherited copies without touching siblings.
+        for (const [id, previous] of parked) {
+            await request(`${previous.app.recorderEndpoint}/recordings/${id}`, "DELETE");
+            parked.delete(id);
+        }
+        for (const app of apps)
+            await capture(app);
+        assertActive();
+    }
+    async function open(app) {
+        assertActive();
+        if (!isAndroidApp(app))
+            throw new Error("ctx.android(): pass the handle from an android() service");
+        let pending = handles.get(app.name);
+        if (pending)
+            return pending;
+        pending = (async () => {
+            await capture(app);
+            assertActive();
+            const sid = await session(app);
+            assertActive();
+            const command = (method, path, body) => {
+                assertActive();
+                return request(`${app.endpoint}/session/${encodeURIComponent(sid)}${path}`, method, body);
+            };
+            async function tapMarker(point) {
+                if (!captures.has(app.name) || app.showTouches === false)
+                    return;
+                // Appium injects touches after Android's physical-touch visualizer.
+                // Keep markers alongside the video; never change tap semantics or fail
+                // a test just because optional visual feedback could not be measured.
+                try {
+                    const screen = await command("GET", "/window/rect");
+                    const rect = typeof point === "string"
+                        ? await command("GET", `${point}/rect`)
+                        : { ...point, width: 0, height: 0 };
+                    const x = (rect.x + rect.width / 2) / screen.width;
+                    const y = (rect.y + rect.height / 2) / screen.height;
+                    if (![x, y].every(v => Number.isFinite(v) && v >= 0 && v <= 1))
+                        return;
+                    return { x, y, offsetMs: Date.now() - testStartedAt };
+                }
+                catch {
+                    return;
+                }
+            }
+            function saveTap(marker) {
+                if (!marker || !active)
+                    return;
+                const list = taps.get(app.name) ?? [];
+                if (list.length < 10000)
+                    list.push(marker);
+                taps.set(app.name, list);
+            }
+            async function op(operation, fn) {
+                assertActive();
+                const android = { device: app.name, ...operation };
+                const title = androidStepTitle(android);
+                const reservation = reserveEvent(), started = Date.now();
+                try {
+                    const result = await fn();
+                    const seq = recordStep({
+                        kind: "android",
+                        title,
+                        android,
+                        durationMs: Date.now() - started,
+                        status: "passed",
+                    }, reservation);
+                    return wrap(result, seq);
+                }
+                catch (error) {
+                    recordStep({
+                        kind: "android",
+                        title,
+                        android,
+                        durationMs: Date.now() - started,
+                        status: "failed",
+                        error: String(error),
+                    }, reservation);
+                    throw error;
+                }
+            }
+            const element = (using, value, target = androidTarget(using, value)) => {
+                const label = androidTargetLabel(target);
+                const find = async () => {
+                    const result = await command("POST", "/element", {
+                        using,
+                        value,
+                    });
+                    const id = result["element-6066-11e4-a52e-4f735466cecf"];
+                    if (!id)
+                        throw new Error("Appium returned no element id");
+                    return `/element/${encodeURIComponent(id)}`;
+                };
+                const displayed = async () => {
+                    try {
+                        return await command("GET", `${await find()}/displayed`);
+                    }
+                    catch (error) {
+                        if (error instanceof AppiumError &&
+                            ["no such element", "stale element reference"].includes(error.code))
+                            return false;
+                        throw error;
+                    }
+                };
+                return {
+                    async tap() {
+                        await op({ action: "tap", target }, async () => {
+                            const path = await find();
+                            const marker = await tapMarker(path);
+                            await command("POST", `${path}/click`, {});
+                            saveTap(marker);
+                        });
+                    },
+                    async fill(text) {
+                        await op({ action: "fill", target }, async () => {
+                            const path = await find();
+                            await command("POST", `${path}/clear`, {});
+                            await command("POST", `${path}/value`, { text });
+                        });
+                    },
+                    text: () => op({ action: "text", target }, async () => command("GET", `${await find()}/text`)),
+                    isDisplayed: () => op({ action: "visible", target }, displayed),
+                    async waitFor(options = {}) {
+                        const timeout = options.timeoutMs ?? 10000;
+                        if (!Number.isFinite(timeout) || timeout < 0)
+                            throw new Error("Invalid wait timeout");
+                        await op({ action: "wait", target, state: options.state ?? "visible" }, async () => {
+                            const end = Date.now() + timeout;
+                            do {
+                                if ((await displayed()) === (options.state !== "hidden"))
+                                    return;
+                                await new Promise((resolve) => setTimeout(resolve, 100));
+                            } while (Date.now() < end);
+                            throw new Error(`Timed out waiting for ${label}`);
+                        });
+                    },
+                };
+            };
+            return {
+                locator: element,
+                getByAccessibilityId: (id) => element("accessibility id", id),
+                getById: (id) => element("id", id),
+                getByText: (text) => element("-android uiautomator", `new UiSelector().text(${JSON.stringify(text)})`, { kind: "text", value: text }),
+                async tap(x, y) {
+                    await op({ action: "tap", point: { x, y } }, async () => {
+                        const marker = await tapMarker({ x, y });
+                        await command("POST", "/execute/sync", { script: "mobile: clickGesture", args: [{ x, y }] });
+                        saveTap(marker);
+                    });
+                },
+                async swipe(direction) {
+                    await op({ action: "swipe", direction }, async () => {
+                        const rect = await command("GET", "/window/rect");
+                        await command("POST", "/execute/sync", {
+                            script: "mobile: swipeGesture",
+                            args: [
+                                {
+                                    left: rect.width * 0.1,
+                                    top: rect.height * 0.1,
+                                    width: rect.width * 0.8,
+                                    height: rect.height * 0.8,
+                                    direction,
+                                    percent: 0.75,
+                                },
+                            ],
+                        });
+                    });
+                },
+                async back() {
+                    await op({ action: "back" }, () => command("POST", "/back", {}));
+                },
+                pageSource: () => op({ action: "source" }, () => command("GET", "/source")),
+                async screenshot() {
+                    const value = await op({ action: "screenshot" }, () => command("GET", "/screenshot"));
+                    return Buffer.from(value.unwrap(), "base64");
+                },
+                execute: (script, args = {}) => op({ action: "execute", command: script }, () => command("POST", "/execute/sync", { script, args: [args] })),
+            };
+        })();
+        handles.set(app.name, pending);
+        return pending;
+    }
+    async function finish() {
+        active = false;
+        const result = [];
+        for (const [name, pending] of captures) {
+            let owner;
+            let recording = {
+                id: "",
+                name,
+                package: "",
+                openedAtMs: 0,
+                closedAtMs: Date.now() - testStartedAt,
+                mediaDurationMs: 0,
+                width: 0,
+                height: 0,
+                bytes: 0,
+                taps: taps.get(name) ?? [],
+            };
+            try {
+                const { app, id, openedAtMs } = await pending;
+                owner = app;
+                recording = { ...recording, id, package: app.package, openedAtMs };
+                const stopped = await request(`${app.recorderEndpoint}/recordings/${id}/stop`, "POST");
+                recording = {
+                    ...recording,
+                    bytes: stopped.bytes,
+                    width: stopped.width,
+                    height: stopped.height,
+                    mediaDurationMs: stopped.mediaDurationMs,
+                    closedAtMs: Math.max(openedAtMs, stopped.closedAtMs - testStartedAt),
+                };
+                parked.set(id, { app, recording });
+            }
+            catch (error) {
+                recording.error = String(error);
+                // A failed finalization still owns a file in the tools container.
+                if (recording.id) {
+                    if (owner)
+                        await request(`${owner.recorderEndpoint}/recordings/${recording.id}`, "DELETE").catch(() => { });
+                }
+            }
+            result.push(recording);
+        }
+        return result;
+    }
+    return {
+        begin,
+        open,
+        finish,
+        deactivate: () => {
+            active = false;
+        },
+    };
+}
+export async function androidRecordingChunk(id, offset, limit) {
+    const entry = parked.get(id);
+    if (!entry)
+        throw new Error("Unknown Android recording");
+    const start = Number(offset ?? 0), count = Number(limit ?? 6291456);
+    if (!Number.isSafeInteger(start) ||
+        start < 0 ||
+        !Number.isSafeInteger(count) ||
+        count < 1 ||
+        count > 6291456)
+        throw new Error("Invalid recording chunk range");
+    return request(`${entry.app.recorderEndpoint}/recordings/${id}?offset=${start}&limit=${count}`);
+}
+export async function releaseAndroidRecording(id) {
+    const entry = parked.get(id);
+    if (entry) {
+        await request(`${entry.app.recorderEndpoint}/recordings/${id}`, "DELETE");
+        parked.delete(id);
+    }
+    return { released: true };
+}