mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
600 lines
25 KiB
TypeScript
600 lines
25 KiB
TypeScript
// @effect-diagnostics globalDate:off - scenario windows are wall-clock by nature.
|
|
/**
|
|
* Scenarios drive one flow on the device and return metrics. Cases in `cases.ts` name a
|
|
* scenario and check its metrics, so one flow can serve several issues.
|
|
*/
|
|
import type { ThreadId } from "@hanzodev/contracts";
|
|
import type * as SecureRandom from "effect/crypto/SecureRandom";
|
|
import * as Effect from "effect/Effect";
|
|
import * as Schema from "effect/Schema";
|
|
|
|
import {
|
|
APP_ID,
|
|
SCHEME,
|
|
type AxNode,
|
|
type Device,
|
|
type FeedSample,
|
|
type ProbeState,
|
|
} from "./device.ts";
|
|
import { uuid, type EvalEnvironment } from "./environment.ts";
|
|
import { feedMotion, frameStats, type Metrics } from "./grade.ts";
|
|
|
|
export type Pose = "phone" | "duo-closed" | "duo-open" | "ipad";
|
|
|
|
export interface ScenarioContext {
|
|
readonly env: EvalEnvironment;
|
|
readonly device: Device;
|
|
readonly pose: Pose;
|
|
readonly fixtures: { readonly longThread: ThreadId };
|
|
}
|
|
|
|
// Child thread ids carry `:`, so each segment is encoded.
|
|
const threadPath = (ctx: ScenarioContext, threadId: string) =>
|
|
`threads/${encodeURIComponent(ctx.env.environmentId)}/${encodeURIComponent(threadId)}`;
|
|
|
|
const isThread = (state: ProbeState, threadId: string) =>
|
|
state.route?.name === "Thread" && state.route.params.threadId === threadId;
|
|
|
|
const openThread = Effect.fn("scenario.openThread")(function* (
|
|
ctx: ScenarioContext,
|
|
threadId: string,
|
|
) {
|
|
yield* ctx.device.open(threadPath(ctx, threadId));
|
|
return yield* ctx.device.waitFor(
|
|
`thread ${threadId} with a ready feed`,
|
|
(state) => isThread(state, threadId) && state.feed?.threadId === threadId && state.feed.ready,
|
|
20_000,
|
|
);
|
|
});
|
|
|
|
/** Screen size in points, and the x of the thread column (the right column in split view). */
|
|
const geometry = Effect.fn("scenario.geometry")(function* (ctx: ScenarioContext) {
|
|
const nodes = yield* ctx.device.nodes;
|
|
const rect = nodes[0]?.rect ?? { x: 0, y: 0, width: 400, height: 870 };
|
|
const state = yield* ctx.device.state;
|
|
return {
|
|
width: rect.width,
|
|
height: rect.height,
|
|
threadX: Math.round(rect.width * (state.route?.columns ? 0.72 : 0.5)),
|
|
};
|
|
});
|
|
|
|
const findNode = Effect.fn("scenario.findNode")(function* (
|
|
ctx: ScenarioContext,
|
|
description: string,
|
|
match: (node: { label?: string; value?: string; kind?: string; editable?: boolean }) => boolean,
|
|
) {
|
|
const node = (yield* ctx.device.nodes).find(match);
|
|
if (!node?.rect) return yield* new ScenarioFailure({ message: `No ${description} on screen.` });
|
|
return node;
|
|
});
|
|
|
|
const composerNode = (ctx: ScenarioContext) =>
|
|
findNode(
|
|
ctx,
|
|
"composer text view",
|
|
(node) => node.kind === "text-view" && node.editable === true,
|
|
);
|
|
|
|
/** The text the native editor shows, read from the accessibility tree rather than React props. */
|
|
const composerText = Effect.fn("scenario.composerText")(function* (ctx: ScenarioContext) {
|
|
const node = yield* composerNode(ctx);
|
|
return node.value ?? node.label ?? "";
|
|
});
|
|
|
|
/** A fresh settled thread, so drafts left by earlier samples never mix in. */
|
|
const freshThread = Effect.fn("scenario.freshThread")(function* (
|
|
ctx: ScenarioContext,
|
|
prompt = "Hi. [[eval:reply]]",
|
|
) {
|
|
const threadId = yield* ctx.env.launch(`Fresh ${(yield* uuid).slice(0, 6)}`, prompt);
|
|
if (!prompt.includes("[[eval:stream")) yield* ctx.env.settled(threadId);
|
|
return threadId;
|
|
});
|
|
|
|
/** Replaces the composer's text, the way a person would after clearing it. */
|
|
const typeInComposer = Effect.fn("scenario.typeInComposer")(function* (
|
|
ctx: ScenarioContext,
|
|
text: string,
|
|
) {
|
|
const { x, y } = ctx.device.center(yield* composerNode(ctx));
|
|
yield* ctx.device.run(["fill", String(x), String(y), text]);
|
|
// The composer slides up with the keyboard; a tap before it settles lands on the keyboard.
|
|
yield* ctx.device.waitFor("the keyboard", (state) => state.composer.keyboard, 10_000);
|
|
yield* Effect.sleep("1 second");
|
|
});
|
|
|
|
const countUserText = (
|
|
projection: { readonly messages: ReadonlyArray<{ readonly text?: string }> },
|
|
text: string,
|
|
) => projection.messages.filter((message) => message.text === text).length;
|
|
|
|
/** Starts a scripted reply in `threadId` and waits until the app shows it streaming. */
|
|
const startStream = Effect.fn("scenario.startStream")(function* (
|
|
ctx: ScenarioContext,
|
|
threadId: ThreadId,
|
|
script: string,
|
|
) {
|
|
const before = (yield* ctx.device.state).feed?.content ?? 0;
|
|
yield* ctx.env.send(threadId, `Write the long report. ${script}`);
|
|
yield* ctx.device.waitFor(
|
|
"the reply to start streaming in the feed",
|
|
(state) => (state.feed?.content ?? 0) > before + 200,
|
|
20_000,
|
|
);
|
|
});
|
|
|
|
/** Records frames (and the visible feed) while `action` runs; the action's failure is not the metric. */
|
|
/** Records frames (and the visible feed) while `action` runs; stops recording even if it fails. */
|
|
const recordFor = <E, R>(
|
|
ctx: ScenarioContext,
|
|
withFeed: boolean,
|
|
action: Effect.Effect<unknown, E, R>,
|
|
) =>
|
|
ctx.device.recordStart(withFeed).pipe(
|
|
Effect.andThen(Effect.exit(action)),
|
|
Effect.flatMap((exit) =>
|
|
ctx.device.recordStop.pipe(Effect.flatMap((recording) => Effect.as(exit, recording))),
|
|
),
|
|
);
|
|
|
|
/** JS frame times jitter, so the display's refresh rate comes from the UI thread's vsync times. */
|
|
const frameMetrics = (recording: { js: ReadonlyArray<number>; ui: ReadonlyArray<number> }) => {
|
|
const ui = frameStats(recording.ui, "ui");
|
|
const refreshMs = typeof ui.uiRefreshHz === "number" ? 1000 / ui.uiRefreshHz : undefined;
|
|
return { ...frameStats(recording.js, "js", refreshMs), ...ui };
|
|
};
|
|
|
|
/** Every scenario fails with this one error, so the table has a single function type. */
|
|
export class ScenarioFailure extends Schema.TaggedError<ScenarioFailure>()("ScenarioFailure", {
|
|
message: Schema.String,
|
|
}) {}
|
|
|
|
const failure = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
|
|
Effect.mapError(
|
|
effect,
|
|
(error) =>
|
|
new ScenarioFailure({ message: error instanceof Error ? error.message : String(error) }),
|
|
);
|
|
|
|
type Scenario = (
|
|
ctx: ScenarioContext,
|
|
) => Effect.Effect<Metrics, ScenarioFailure, SecureRandom.SecureRandom>;
|
|
|
|
export const SCENARIOS = {
|
|
/** Six upward flings in the long settled thread. */
|
|
scrollUpLongThread: Effect.fn("scenario.scrollUpLongThread")(function* (ctx: ScenarioContext) {
|
|
yield* openThread(ctx, ctx.fixtures.longThread);
|
|
const { height, threadX } = yield* geometry(ctx);
|
|
const recording = yield* recordFor(
|
|
ctx,
|
|
true,
|
|
Effect.gen(function* () {
|
|
for (let fling = 0; fling < 6; fling++)
|
|
yield* ctx.device.swipe(threadX, Math.round(height * 0.35), Math.round(height * 0.8));
|
|
yield* Effect.sleep("1 second");
|
|
}),
|
|
);
|
|
return { ...feedMotion(recording.feed, 1), ...frameMetrics(recording) } satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** A long reply streams into the open thread for eight seconds. */
|
|
streamInView: Effect.fn("scenario.streamInView")(function* (ctx: ScenarioContext) {
|
|
yield* openThread(ctx, ctx.fixtures.longThread);
|
|
yield* startStream(ctx, ctx.fixtures.longThread, "[[eval:stream:4000:25]]");
|
|
const recording = yield* recordFor(ctx, true, Effect.sleep("8 seconds"));
|
|
const after = yield* ctx.device.state;
|
|
yield* ctx.env.interruptAll();
|
|
const motion = feedMotion(recording.feed, 0);
|
|
return {
|
|
...motion,
|
|
...frameMetrics(recording),
|
|
settledFromEndPx: settledFromEnd(recording.feed),
|
|
contentGrewPx: (recording.feed.at(-1)?.content ?? 0) - (recording.feed[0]?.content ?? 0),
|
|
followingAtEnd: after.feed?.following === true,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Types and sends a message from the composer at the end of the long thread. */
|
|
sendInLongThread: Effect.fn("scenario.sendInLongThread")(function* (ctx: ScenarioContext) {
|
|
yield* openThread(ctx, ctx.fixtures.longThread);
|
|
const text = `Follow-up ${(yield* uuid).slice(0, 8)} [[eval:reply]]`;
|
|
yield* typeInComposer(ctx, text);
|
|
const recording = yield* recordFor(
|
|
ctx,
|
|
true,
|
|
Effect.gen(function* () {
|
|
yield* ctx.device.press('label="Send"');
|
|
yield* Effect.sleep("4 seconds");
|
|
}),
|
|
);
|
|
const after = yield* ctx.device.state;
|
|
const nativeText = yield* composerText(ctx);
|
|
const projection = yield* ctx.env.settled(ctx.fixtures.longThread);
|
|
const motion = feedMotion(recording.feed, 0);
|
|
return {
|
|
maxFromEndPx: motion.maxFromEndPx ?? null,
|
|
finalFromEndPx: motion.finalFromEndPx ?? null,
|
|
serverMessages: countUserText(projection, text),
|
|
draftCleared: after.composer.draft === "",
|
|
editorCleared: nativeText === "",
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** A thread in the background finishes while the long thread sits mid-scroll. */
|
|
backgroundFinish: Effect.fn("scenario.backgroundFinish")(function* (ctx: ScenarioContext) {
|
|
const key = `bg-${(yield* uuid).slice(0, 8)}`;
|
|
const other = yield* ctx.env.launch("Background work", `Run the job. [[eval:hold:${key}]]`);
|
|
yield* openThread(ctx, ctx.fixtures.longThread);
|
|
const { height, threadX } = yield* geometry(ctx);
|
|
for (let fling = 0; fling < 2; fling++)
|
|
yield* ctx.device.swipe(threadX, Math.round(height * 0.4), Math.round(height * 0.7));
|
|
yield* waitForStill(ctx);
|
|
const recording = yield* recordFor(
|
|
ctx,
|
|
true,
|
|
Effect.gen(function* () {
|
|
yield* ctx.env.release(key);
|
|
yield* ctx.env.settled(other);
|
|
yield* Effect.sleep("2 seconds");
|
|
}),
|
|
);
|
|
return { ...feedMotion(recording.feed, 0) } satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Types in a streaming thread, switches to another thread, and comes back. */
|
|
draftThreadSwitch: Effect.fn("scenario.draftThreadSwitch")(function* (ctx: ScenarioContext) {
|
|
const text = `Draft ${(yield* uuid).slice(0, 8)}`;
|
|
const other = yield* freshThread(ctx);
|
|
const streaming = yield* freshThread(ctx, "Write the long report. [[eval:stream:4000:25]]");
|
|
yield* openThread(ctx, streaming);
|
|
yield* typeInComposer(ctx, text);
|
|
yield* openThread(ctx, other);
|
|
yield* Effect.sleep("1 second");
|
|
const onOther = yield* ctx.device.state;
|
|
const otherText = yield* composerText(ctx);
|
|
yield* openThread(ctx, streaming);
|
|
yield* Effect.sleep("1 second");
|
|
const back = yield* ctx.device.state;
|
|
const backText = yield* composerText(ctx);
|
|
yield* ctx.env.interruptAll();
|
|
const otherKey = `${ctx.env.environmentId}:${other}`;
|
|
return {
|
|
draftKept: back.composer.draft === text,
|
|
editorShowsDraft: backText === text,
|
|
leakedIntoOtherDraft: (onOther.composer.drafts[otherKey] ?? "") !== "",
|
|
leakedIntoOtherEditor: otherText.includes(text),
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Types a draft, sends the app to the background, and brings it back. */
|
|
draftBackground: Effect.fn("scenario.draftBackground")(function* (ctx: ScenarioContext) {
|
|
const text = `Draft ${(yield* uuid).slice(0, 8)}`;
|
|
const threadId = yield* freshThread(ctx);
|
|
yield* openThread(ctx, threadId);
|
|
yield* typeInComposer(ctx, text);
|
|
yield* ctx.device.home;
|
|
yield* Effect.sleep("3 seconds");
|
|
// A link back to the thread foregrounds the running app; a plain open would reload its JS.
|
|
yield* ctx.device.run([
|
|
"open",
|
|
APP_ID,
|
|
"--launch-url",
|
|
`${SCHEME}://${threadPath(ctx, threadId)}`,
|
|
]);
|
|
const back = yield* ctx.device.waitFor("the thread after foreground", (state) =>
|
|
isThread(state, threadId),
|
|
);
|
|
return {
|
|
draftKept: back.composer.draft === text,
|
|
editorShowsDraft: (yield* composerText(ctx)) === text,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Taps the middle of the composer's text area. */
|
|
tapComposer: Effect.fn("scenario.tapComposer")(function* (ctx: ScenarioContext) {
|
|
const threadId = yield* freshThread(ctx);
|
|
yield* openThread(ctx, threadId);
|
|
const node = yield* composerNode(ctx);
|
|
const { x, y } = ctx.device.center(node);
|
|
yield* ctx.device.pressAt(x, y);
|
|
yield* Effect.sleep("1500 millis");
|
|
const after = yield* ctx.device.state;
|
|
return {
|
|
stayedOnThread: isThread(after, threadId),
|
|
editorFocused:
|
|
after.composer.editors.some((editor) => editor.expanded) && after.composer.keyboard,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Types `/eval`, picks the workspace's `eval-notes` skill, and checks the editor keeps focus. */
|
|
skillPick: Effect.fn("scenario.skillPick")(function* (ctx: ScenarioContext) {
|
|
yield* openThread(ctx, yield* freshThread(ctx));
|
|
// Short screens fit one menu row above the keyboard, so filter the menu to one row.
|
|
yield* typeInComposer(ctx, "/eval");
|
|
const composer = yield* composerNode(ctx);
|
|
// Menu rows read "<icon>, skill:<name>, <description>". Skills arrive with a workspace
|
|
// snapshot the draft change requests.
|
|
let item: AxNode | undefined;
|
|
for (let attempt = 0; attempt < 10 && !item?.rect; attempt++) {
|
|
yield* Effect.sleep("1 second");
|
|
item = (yield* ctx.device.nodes).find(
|
|
(node) =>
|
|
node.rect !== undefined &&
|
|
node.rect.y + node.rect.height <= composer.rect!.y &&
|
|
node.label?.includes(", skill:eval-notes") === true,
|
|
);
|
|
}
|
|
if (!item?.rect)
|
|
return yield* new ScenarioFailure({ message: "The / menu did not list skill:eval-notes." });
|
|
const { x, y } = ctx.device.center(item);
|
|
yield* ctx.device.pressAt(x, y);
|
|
yield* Effect.sleep("1500 millis");
|
|
const after = yield* ctx.device.state;
|
|
return {
|
|
editorFocused:
|
|
after.composer.editors.some((editor) => editor.expanded) && after.composer.keyboard,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Sends from a thread whose provider instance the server no longer has. */
|
|
failedSend: Effect.fn("scenario.failedSend")(function* (ctx: ScenarioContext) {
|
|
const { threadId, lock } = yield* ctx.env.launchLockable("Locked thread");
|
|
yield* openThread(ctx, threadId);
|
|
const text = `Will fail ${(yield* uuid).slice(0, 8)}`;
|
|
yield* typeInComposer(ctx, text);
|
|
yield* lock;
|
|
// The app learns of the setting a moment after the server commits it.
|
|
yield* Effect.sleep("2 seconds");
|
|
// Either outcome is honest: Send turns off, or the rejected send shows an error.
|
|
const sendBlocked =
|
|
(yield* ctx.device.nodes).find((node) => node.label === "Send")?.enabled === false;
|
|
if (!sendBlocked) yield* ctx.device.press('label="Send"');
|
|
const shown = sendBlocked
|
|
? false
|
|
: (yield* ctx.device
|
|
.waitFor("a composer error", (state) => state.composer.error !== null, 8_000)
|
|
.pipe(Effect.option))._tag === "Some";
|
|
return {
|
|
sendBlocked,
|
|
errorShown: shown,
|
|
silentFailure: !sendBlocked && !shown,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** A working thread finishes while Home is open. */
|
|
workingShelfFinish: Effect.fn("scenario.workingShelfFinish")(function* (ctx: ScenarioContext) {
|
|
const key = `shelf-${(yield* uuid).slice(0, 8)}`;
|
|
const threadId = yield* ctx.env.launch("Shelf work", `Run the job. [[eval:hold:${key}]]`);
|
|
const working = yield* ctx.device.waitFor(
|
|
"the thread to show as working",
|
|
(state) => state.threads[threadId] === "working",
|
|
);
|
|
yield* ctx.env.release(key);
|
|
yield* ctx.env.settled(threadId);
|
|
// The shelf keeps a finished row for WORKING_EXIT_GRACE_MS (2 s) on purpose.
|
|
yield* Effect.sleep("5 seconds");
|
|
const after = yield* ctx.device.state;
|
|
return {
|
|
shelfShownWhileWorking: shelfCount(working) > 0,
|
|
shelfCountAfter: shelfCount(after),
|
|
// For diagnosis: threads the app itself calls working, beside the shelf's count.
|
|
appWorkingThreads: Object.values(after.threads).filter((status) => status === "working")
|
|
.length,
|
|
statusAfter: after.threads[threadId] ?? "missing",
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** A thread asks a question while Home is open. */
|
|
pendingQuestion: Effect.fn("scenario.pendingQuestion")(function* (ctx: ScenarioContext) {
|
|
const threadId = yield* ctx.env.launch("Question", `Ask me first. [[eval:question]]`);
|
|
yield* ctx.env.waitForPendingInput(threadId);
|
|
yield* Effect.sleep("2 seconds");
|
|
const after = yield* ctx.device.state;
|
|
yield* ctx.env.interruptAll();
|
|
return {
|
|
status: after.threads[threadId] ?? "missing",
|
|
shelfCount: shelfCount(after),
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** A thread runs two subagents; Home and the thread must not look idle. */
|
|
subagentsRunning: Effect.fn("scenario.subagentsRunning")(function* (ctx: ScenarioContext) {
|
|
const key = `sub-${(yield* uuid).slice(0, 8)}`;
|
|
const threadId = yield* ctx.env.launch("Subagents", `Fan out. [[eval:subagents:${key}]]`);
|
|
yield* ctx.env.waitForSubagents(threadId);
|
|
yield* Effect.sleep("2 seconds");
|
|
const home = yield* ctx.device.state;
|
|
yield* openThread(ctx, threadId);
|
|
yield* Effect.sleep("1500 millis");
|
|
const thread = yield* ctx.device.state;
|
|
yield* ctx.env.release(key);
|
|
yield* ctx.env.settled(threadId);
|
|
return {
|
|
status: home.threads[threadId] ?? "missing",
|
|
threadShowsStatus: thread.floatingStatus !== null,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Scrolls a finished subagent's child thread. */
|
|
openSubagentThread: Effect.fn("scenario.openSubagentThread")(function* (ctx: ScenarioContext) {
|
|
const key = `child-${(yield* uuid).slice(0, 8)}`;
|
|
const threadId = yield* ctx.env.launch("Parent", `Fan out. [[eval:subagents:${key}]]`);
|
|
yield* ctx.env.waitForSubagents(threadId);
|
|
yield* ctx.env.release(key);
|
|
const projection = yield* ctx.env.settled(threadId);
|
|
const child = projection.subagents.find(
|
|
(subagent) => subagent.childThreadId !== null,
|
|
)?.childThreadId;
|
|
if (!child)
|
|
return yield* new ScenarioFailure({ message: "The subagent made no child thread." });
|
|
yield* openThread(ctx, child);
|
|
const { height, threadX } = yield* geometry(ctx);
|
|
const recording = yield* recordFor(
|
|
ctx,
|
|
true,
|
|
Effect.gen(function* () {
|
|
yield* ctx.device.swipe(threadX, Math.round(height * 0.7), Math.round(height * 0.3));
|
|
yield* ctx.device.swipe(threadX, Math.round(height * 0.3), Math.round(height * 0.7));
|
|
}),
|
|
);
|
|
return {
|
|
movedPx: feedMotion(recording.feed, 0).movedPx ?? 0,
|
|
...frameMetrics(recording),
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Long-presses a row on Home and picks Pin. */
|
|
pinFromLongPress: Effect.fn("scenario.pinFromLongPress")(function* (ctx: ScenarioContext) {
|
|
const title = `Pin target ${(yield* uuid).slice(0, 6)}`;
|
|
const target = yield* ctx.env.launch(title, "Hi. [[eval:reply]]");
|
|
yield* ctx.env.settled(target);
|
|
yield* waitForRow(ctx, title);
|
|
// A just-inserted row can swallow the first long-press while it animates in.
|
|
for (let attempt = 0; attempt < 2; attempt++) {
|
|
yield* ctx.device.longPress(rowSelector(title));
|
|
yield* Effect.sleep("1 second");
|
|
if ((yield* ctx.device.nodes).some((node) => node.label === "Pin")) break;
|
|
}
|
|
yield* ctx.device.press('label="Pin"');
|
|
yield* Effect.sleep("2 seconds");
|
|
const shell = yield* ctx.env.shell();
|
|
const pinned = shell.threads
|
|
.filter((thread) => thread.pinnedAt != null)
|
|
.map((thread) => thread.id);
|
|
for (const id of pinned) yield* ctx.env.unpin(id);
|
|
return {
|
|
targetPinned: pinned.includes(target),
|
|
otherPinned: pinned.filter((id) => id !== target).length,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Opens a link to a thread created after the app loaded its list. */
|
|
linkToNewThread: Effect.fn("scenario.linkToNewThread")(function* (ctx: ScenarioContext) {
|
|
const threadId = yield* ctx.env.launch("Linked thread", "Hi. [[eval:reply]]");
|
|
yield* ctx.device.open(threadPath(ctx, threadId));
|
|
yield* Effect.sleep("4 seconds");
|
|
const after = yield* ctx.device.state;
|
|
return { opensTarget: isThread(after, threadId) } satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Opens a link to an archived thread. */
|
|
linkToArchivedThread: Effect.fn("scenario.linkToArchivedThread")(function* (
|
|
ctx: ScenarioContext,
|
|
) {
|
|
const threadId = yield* ctx.env.launch("Archived thread", "Hi. [[eval:reply]]");
|
|
yield* ctx.env.settled(threadId);
|
|
yield* ctx.env.archive(threadId);
|
|
yield* Effect.sleep("1 second");
|
|
yield* ctx.device.open(threadPath(ctx, threadId));
|
|
yield* Effect.sleep("4 seconds");
|
|
const after = yield* ctx.device.state;
|
|
return { opensTarget: isThread(after, threadId) } satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** Taps a row on Home. */
|
|
openFromList: Effect.fn("scenario.openFromList")(function* (ctx: ScenarioContext) {
|
|
const title = `Open me ${(yield* uuid).slice(0, 6)}`;
|
|
const target = yield* ctx.env.launch(title, "Hi. [[eval:reply]]");
|
|
yield* ctx.env.settled(target);
|
|
yield* waitForRow(ctx, title);
|
|
// A just-inserted row animates in, and a tap during that misses it.
|
|
yield* Effect.sleep("1 second");
|
|
yield* ctx.device.press(rowSelector(title));
|
|
const after = yield* ctx.device
|
|
.waitFor("the tapped thread", (state) => isThread(state, target))
|
|
.pipe(Effect.option);
|
|
return { opensTarget: after._tag === "Some" } satisfies Metrics;
|
|
}, failure),
|
|
|
|
/** On a folded Duo: open a thread from the list, go back, and open another. */
|
|
duoBackThenOpen: Effect.fn("scenario.duoBackThenOpen")(function* (ctx: ScenarioContext) {
|
|
const tag = (yield* uuid).slice(0, 6);
|
|
const first = yield* ctx.env.launch(`Duo first ${tag}`, "Hi. [[eval:reply]]");
|
|
const next = yield* ctx.env.launch(`Duo next ${tag}`, "Hi. [[eval:reply]]");
|
|
yield* ctx.env.settled(first);
|
|
yield* ctx.env.settled(next);
|
|
yield* waitForRow(ctx, `Duo first ${tag}`);
|
|
yield* ctx.device.press(rowSelector(`Duo first ${tag}`));
|
|
yield* ctx.device.waitFor("the first thread", (state) => isThread(state, first));
|
|
yield* ctx.device.back;
|
|
yield* ctx.device.waitFor("Home", (state) => state.route?.name === "Home");
|
|
yield* ctx.device.press(rowSelector(`Duo next ${tag}`));
|
|
yield* Effect.sleep("2 seconds");
|
|
const after = yield* ctx.device.state;
|
|
// A thread can mount in a hidden column, so its title must sit inside the visible screen.
|
|
const nodes = yield* ctx.device.nodes;
|
|
const screen = nodes[0]?.rect;
|
|
// The header title is a text node inside a navigation bar; a Home row with the title is not.
|
|
const bars = nodes.flatMap((node) =>
|
|
node.kind === "navigation-bar" && node.rect ? [node.rect] : [],
|
|
);
|
|
const title = nodes.find(
|
|
(node) =>
|
|
node.label === `Duo next ${tag}` &&
|
|
bars.some((bar) => node.rect && node.rect.y >= bar.y && node.rect.y < bar.y + bar.height),
|
|
)?.rect;
|
|
return {
|
|
opensTarget: isThread(after, next),
|
|
titleOnScreen:
|
|
screen !== undefined &&
|
|
title !== undefined &&
|
|
title.x >= screen.x &&
|
|
title.x + title.width <= screen.x + screen.width,
|
|
} satisfies Metrics;
|
|
}, failure),
|
|
} satisfies Record<string, Scenario>;
|
|
|
|
export type ScenarioName = keyof typeof SCENARIOS;
|
|
|
|
/** Row rects are relative to their list, so rows are tapped by label, not by point. */
|
|
function rowSelector(title: string) {
|
|
return `label="${title}"`;
|
|
}
|
|
|
|
/** Waits until fling momentum ends: the feed's offset holds still across half a second. */
|
|
const waitForStill = Effect.fn("scenario.waitForStill")(function* (ctx: ScenarioContext) {
|
|
let previous = -1;
|
|
for (let attempt = 0; attempt < 20; attempt++) {
|
|
const scroll = (yield* ctx.device.state).feed?.scroll ?? -1;
|
|
if (scroll === previous) return;
|
|
previous = scroll;
|
|
yield* Effect.sleep("500 millis");
|
|
}
|
|
});
|
|
|
|
/** Largest distance from the end on frames where the content did not just grow. */
|
|
function settledFromEnd(samples: ReadonlyArray<FeedSample>) {
|
|
let worst = 0;
|
|
for (let index = 1; index < samples.length; index++)
|
|
if (samples[index]!.content === samples[index - 1]!.content)
|
|
worst = Math.max(worst, samples[index]!.fromEnd ?? 0);
|
|
return worst;
|
|
}
|
|
|
|
/** Waits until a row with this title is on screen. */
|
|
const waitForRow = Effect.fn("scenario.waitForRow")(function* (
|
|
ctx: ScenarioContext,
|
|
title: string,
|
|
) {
|
|
for (let attempt = 0; attempt < 20; attempt++) {
|
|
const nodes = yield* ctx.device.nodes;
|
|
if (nodes.some((node) => node.label?.includes(title))) return;
|
|
// A crowded list can hold the new row below the fold; scroll to the top once.
|
|
if (attempt === 4) yield* ctx.device.run(["scroll", "top"]).pipe(Effect.ignore);
|
|
// A finished row can stay folded in the Working shelf; open it once if it is collapsed.
|
|
const shelf = nodes.find((node) => /^\d+ working threads?$/.test(node.label ?? ""));
|
|
const collapsed = (yield* ctx.device.state).homeList?.some(
|
|
(entry) => entry.type === "v2-working-shelf" && entry.expanded === false,
|
|
);
|
|
if (attempt === 10 && collapsed && shelf?.label)
|
|
yield* ctx.device.press(`label="${shelf.label}"`);
|
|
yield* Effect.sleep("500 millis");
|
|
}
|
|
return yield* new ScenarioFailure({ message: `Row "${title}" never appeared on Home.` });
|
|
});
|
|
|
|
function shelfCount(state: ProbeState) {
|
|
return state.homeList?.find((entry) => entry.type === "v2-working-shelf")?.count ?? 0;
|
|
}
|