@shivaedev/test-story 0.29.0 → 0.31.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +30 -0
- package/README.md +135 -34
- package/dist/server/adapters/outcomeMatchers.d.ts +12 -0
- package/dist/server/adapters/outcomeMatchers.d.ts.map +1 -0
- package/dist/server/adapters/outcomeMatchers.js +22 -0
- package/dist/server/adapters/outcomeMatchers.js.map +1 -0
- package/dist/server/{internal → adapters}/screenElements.d.ts +5 -2
- package/dist/server/adapters/screenElements.d.ts.map +1 -0
- package/dist/server/{internal → adapters}/screenElements.js +22 -5
- package/dist/server/adapters/screenElements.js.map +1 -0
- package/dist/server/adapters/screenMutations.d.ts +3 -0
- package/dist/server/adapters/screenMutations.d.ts.map +1 -0
- package/dist/server/adapters/screenMutations.js +11 -0
- package/dist/server/adapters/screenMutations.js.map +1 -0
- package/dist/server/adapters/screenNavigation.d.ts +3 -0
- package/dist/server/adapters/screenNavigation.d.ts.map +1 -0
- package/dist/server/adapters/screenNavigation.js +34 -0
- package/dist/server/adapters/screenNavigation.js.map +1 -0
- package/dist/server/adapters/screenQueries.d.ts +8 -0
- package/dist/server/adapters/screenQueries.d.ts.map +1 -0
- package/dist/server/adapters/screenQueries.js +62 -0
- package/dist/server/adapters/screenQueries.js.map +1 -0
- package/dist/server/fakeHttpService.d.ts +2 -0
- package/dist/server/fakeHttpService.d.ts.map +1 -1
- package/dist/server/fakeHttpService.js +6 -1
- package/dist/server/fakeHttpService.js.map +1 -1
- package/dist/server/internal/fakeHttpReceive.d.ts +1 -1
- package/dist/server/internal/fakeHttpReceive.d.ts.map +1 -1
- package/dist/server/internal/fakeHttpReceive.js +6 -1
- package/dist/server/internal/fakeHttpReceive.js.map +1 -1
- package/dist/server/internal/nextClientHint.d.ts +4 -0
- package/dist/server/internal/nextClientHint.d.ts.map +1 -0
- package/dist/server/internal/{screenActivity.js → nextClientHint.js} +1 -5
- package/dist/server/internal/nextClientHint.js.map +1 -0
- package/dist/server/internal/recordedSignals.d.ts +8 -0
- package/dist/server/internal/recordedSignals.d.ts.map +1 -0
- package/dist/server/internal/recordedSignals.js +44 -0
- package/dist/server/internal/recordedSignals.js.map +1 -0
- package/dist/server/internal/screenAccessibility.d.ts +0 -1
- package/dist/server/internal/screenAccessibility.d.ts.map +1 -1
- package/dist/server/internal/screenAccessibility.js +1 -22
- package/dist/server/internal/screenAccessibility.js.map +1 -1
- package/dist/server/internal/screenReadouts.d.ts +1 -1
- package/dist/server/internal/screenReadouts.d.ts.map +1 -1
- package/dist/server/internal/screenReadouts.js +3 -3
- package/dist/server/internal/screenReadouts.js.map +1 -1
- package/dist/server/internal/screenWaits.d.ts +28 -0
- package/dist/server/internal/screenWaits.d.ts.map +1 -0
- package/dist/server/internal/screenWaits.js +47 -0
- package/dist/server/internal/screenWaits.js.map +1 -0
- package/dist/server/internal/storyIt.d.ts.map +1 -1
- package/dist/server/internal/storyIt.js +2 -1
- package/dist/server/internal/storyIt.js.map +1 -1
- package/dist/server/internal/waitForScreen.d.ts +9 -0
- package/dist/server/internal/waitForScreen.d.ts.map +1 -0
- package/dist/server/internal/waitForScreen.js +36 -0
- package/dist/server/internal/waitForScreen.js.map +1 -0
- package/dist/server/internal/withWatchedClock.d.ts +3 -0
- package/dist/server/internal/withWatchedClock.d.ts.map +1 -0
- package/dist/server/internal/withWatchedClock.js +6 -0
- package/dist/server/internal/withWatchedClock.js.map +1 -0
- package/dist/server/lineSignals.d.ts +8 -0
- package/dist/server/lineSignals.d.ts.map +1 -0
- package/dist/server/lineSignals.js +21 -0
- package/dist/server/lineSignals.js.map +1 -0
- package/dist/server/otlpReceiver.d.ts +39 -1
- package/dist/server/otlpReceiver.d.ts.map +1 -1
- package/dist/server/otlpReceiver.js +17 -8
- package/dist/server/otlpReceiver.js.map +1 -1
- package/dist/server/outcomes.d.ts +8 -1
- package/dist/server/outcomes.d.ts.map +1 -1
- package/dist/server/outcomes.js +6 -6
- package/dist/server/outcomes.js.map +1 -1
- package/dist/server/screenDriver.d.ts +19 -9
- package/dist/server/screenDriver.d.ts.map +1 -1
- package/dist/server/screenDriver.js +18 -58
- package/dist/server/screenDriver.js.map +1 -1
- package/dist/server/watchedClock.d.ts +10 -0
- package/dist/server/watchedClock.d.ts.map +1 -0
- package/dist/server/watchedClock.js +35 -0
- package/dist/server/watchedClock.js.map +1 -0
- package/package.json +4 -4
- package/src/server/adapters/outcomeMatchers.ts +33 -0
- package/src/server/{internal → adapters}/screenElements.ts +22 -5
- package/src/server/adapters/screenMutations.ts +14 -0
- package/src/server/adapters/screenNavigation.ts +37 -0
- package/src/server/adapters/screenQueries.ts +75 -0
- package/src/server/fakeHttpService.ts +7 -1
- package/src/server/internal/fakeHttpReceive.ts +6 -0
- package/src/server/internal/{screenActivity.ts → nextClientHint.ts} +1 -5
- package/src/server/internal/recordedSignals.ts +44 -0
- package/src/server/internal/screenAccessibility.ts +1 -25
- package/src/server/internal/screenReadouts.ts +3 -3
- package/src/server/internal/screenWaits.ts +105 -0
- package/src/server/internal/storyIt.ts +2 -1
- package/src/server/internal/waitForScreen.ts +48 -0
- package/src/server/internal/withWatchedClock.ts +8 -0
- package/src/server/lineSignals.ts +25 -0
- package/src/server/otlpReceiver.ts +23 -8
- package/src/server/outcomes.ts +19 -10
- package/src/server/screenDriver.ts +25 -73
- package/src/server/watchedClock.ts +49 -0
- package/dist/server/internal/screenActivity.d.ts +0 -5
- package/dist/server/internal/screenActivity.d.ts.map +0 -1
- package/dist/server/internal/screenActivity.js.map +0 -1
- package/dist/server/internal/screenElements.d.ts.map +0 -1
- package/dist/server/internal/screenElements.js.map +0 -1
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
import { isInaccessible } from "dom-accessibility-api";
|
|
2
|
+
import { accessibility, isRendered, targetName } from "#internal/screenAccessibility.ts";
|
|
3
|
+
import { screenText } from "#internal/screenText.ts";
|
|
4
|
+
import type { ScreenTarget } from "#screenDriver.ts";
|
|
5
|
+
|
|
6
|
+
function matchesText(value: string, expected: string | RegExp) {
|
|
7
|
+
return typeof expected === "string" ? value === expected : new RegExp(expected.source, expected.flags).test(value);
|
|
8
|
+
}
|
|
9
|
+
|
|
10
|
+
export function screenQueries(root: () => HTMLElement, dialogs: boolean) {
|
|
11
|
+
function query(selector: string) {
|
|
12
|
+
const current = root();
|
|
13
|
+
const found = new Set(current.querySelectorAll<HTMLElement>(selector));
|
|
14
|
+
const portals = dialogs
|
|
15
|
+
? [...current.ownerDocument.querySelectorAll<HTMLElement>('dialog,[role="dialog"],[role="alertdialog"]')].filter(
|
|
16
|
+
(dialog) => !current.contains(dialog),
|
|
17
|
+
)
|
|
18
|
+
: [];
|
|
19
|
+
for (const dialog of portals) {
|
|
20
|
+
if (dialog.matches(selector)) {
|
|
21
|
+
found.add(dialog);
|
|
22
|
+
}
|
|
23
|
+
for (const child of dialog.querySelectorAll<HTMLElement>(selector)) {
|
|
24
|
+
found.add(child);
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
return [...found];
|
|
28
|
+
}
|
|
29
|
+
function candidates() {
|
|
30
|
+
return query("*")
|
|
31
|
+
.filter((element) => isRendered(element) && !isInaccessible(element))
|
|
32
|
+
.map((element) => {
|
|
33
|
+
const { role, name } = accessibility(element);
|
|
34
|
+
return { element, name: role === "alert" && name === "" ? screenText(element).replace(/\s+/gu, " ").trim() : name, role };
|
|
35
|
+
})
|
|
36
|
+
.filter(({ role }) => role !== null);
|
|
37
|
+
}
|
|
38
|
+
function roles(target: Exclude<ScreenTarget, string>) {
|
|
39
|
+
return candidates().filter(({ role, name }) => role === target.role && matchesText(name, target.name));
|
|
40
|
+
}
|
|
41
|
+
return {
|
|
42
|
+
matches: (target: ScreenTarget) =>
|
|
43
|
+
(typeof target === "string" ? query(target).filter(isRendered) : roles(target).map(({ element }) => element)).filter(
|
|
44
|
+
(element) => element.isConnected,
|
|
45
|
+
),
|
|
46
|
+
query,
|
|
47
|
+
roleElement: (target: Exclude<ScreenTarget, string>) => {
|
|
48
|
+
const matches = roles(target);
|
|
49
|
+
const found = matches[0];
|
|
50
|
+
if (matches.length === 1 && found) {
|
|
51
|
+
return found.element;
|
|
52
|
+
}
|
|
53
|
+
const listing = candidates()
|
|
54
|
+
.map(({ role, name }) => ` - ${role} named ${JSON.stringify(name)}`)
|
|
55
|
+
.join("\n");
|
|
56
|
+
throw new Error(
|
|
57
|
+
`The screen has ${matches.length} matches for ${targetName(target)}.\nhelp: Use a role and name for exactly one visible target.\nCandidates on screen:\n${listing || " (none)"}`,
|
|
58
|
+
);
|
|
59
|
+
},
|
|
60
|
+
textElement: (text: string | RegExp) => {
|
|
61
|
+
const current = root();
|
|
62
|
+
const matches = [current, ...query("*")].filter(
|
|
63
|
+
(element) => isRendered(element) && matchesText(screenText(element).replace(/\s+/gu, " ").trim(), text),
|
|
64
|
+
);
|
|
65
|
+
const deepest = matches.filter((element) => !matches.some((other) => element !== other && element.contains(other)));
|
|
66
|
+
const found = deepest[0];
|
|
67
|
+
if (deepest.length !== 1 || found === undefined) {
|
|
68
|
+
throw new Error(
|
|
69
|
+
`The screen has ${deepest.length} matches for text ${String(text instanceof RegExp ? text : JSON.stringify(text))}.\nhelp: Use text that identifies exactly one visible element.`,
|
|
70
|
+
);
|
|
71
|
+
}
|
|
72
|
+
return found;
|
|
73
|
+
},
|
|
74
|
+
};
|
|
75
|
+
}
|
|
@@ -3,6 +3,8 @@ import { Clock, Effect } from "effect";
|
|
|
3
3
|
import { fakeHttpControls } from "#internal/fakeHttpControls.ts";
|
|
4
4
|
import { fakeHttpReceive } from "#internal/fakeHttpReceive.ts";
|
|
5
5
|
import { loopbackServer } from "#internal/loopback.ts";
|
|
6
|
+
import { recordedSignals } from "#internal/recordedSignals.ts";
|
|
7
|
+
import { type UntilOptions, until } from "#until.ts";
|
|
6
8
|
|
|
7
9
|
export interface FakeHttpRequest {
|
|
8
10
|
readonly body: Buffer;
|
|
@@ -73,8 +75,11 @@ export const fakeHttpService = Effect.fnUntraced(function* (options: FakeHttpSer
|
|
|
73
75
|
narrate?.(line);
|
|
74
76
|
}
|
|
75
77
|
const controls = fakeHttpControls(tell, () => clock.currentTimeMillisUnsafe());
|
|
76
|
-
const
|
|
78
|
+
const abandoned = recordedSignals<FakeHttpRequestRecord>();
|
|
79
|
+
const server = createServer((request, response) => fakeHttpReceive(request, response, options, requests, controls, tell, abandoned.push));
|
|
77
80
|
const url = yield* loopbackServer(server);
|
|
81
|
+
|
|
82
|
+
yield* Effect.addFinalizer(() => Effect.sync(() => abandoned.end()));
|
|
78
83
|
yield* Effect.addFinalizer(controls.close);
|
|
79
84
|
function checkRoute(route: string) {
|
|
80
85
|
if (!Object.hasOwn(options.routes, route)) {
|
|
@@ -100,6 +105,7 @@ export const fakeHttpService = Effect.fnUntraced(function* (options: FakeHttpSer
|
|
|
100
105
|
scriptFault: (route: string, fault: FakeHttpFault, scriptOptions?: FakeHttpScriptOptions) =>
|
|
101
106
|
Effect.sync(() => checkRoute(route)).pipe(Effect.andThen(controls.scriptFault(route, fault, scriptOptions))),
|
|
102
107
|
stall: (route: string, scope?: FakeHttpScope) => Effect.sync(() => checkRoute(route)).pipe(Effect.andThen(controls.stall(route, scope))),
|
|
108
|
+
untilAbandoned: (matches: (request: FakeHttpRequestRecord) => boolean, wait: UntilOptions) => until(abandoned.stream, matches, wait),
|
|
103
109
|
url,
|
|
104
110
|
};
|
|
105
111
|
});
|
|
@@ -63,6 +63,7 @@ export async function fakeHttpReceive(
|
|
|
63
63
|
requests: FakeHttpRequestRecord[],
|
|
64
64
|
controls: ReturnType<typeof fakeHttpControls>,
|
|
65
65
|
tell: (line: string) => void,
|
|
66
|
+
abandoned: (request: FakeHttpRequestRecord) => void,
|
|
66
67
|
) {
|
|
67
68
|
try {
|
|
68
69
|
const path = incoming.url ?? "/";
|
|
@@ -89,6 +90,11 @@ export async function fakeHttpReceive(
|
|
|
89
90
|
},
|
|
90
91
|
};
|
|
91
92
|
requests.push(request);
|
|
93
|
+
response.once("close", () => {
|
|
94
|
+
if (!response.writableFinished) {
|
|
95
|
+
abandoned(request);
|
|
96
|
+
}
|
|
97
|
+
});
|
|
92
98
|
tell(`fake HTTP received ${method} ${path}`);
|
|
93
99
|
if (!decodeParams(params)) {
|
|
94
100
|
tell(`fake HTTP rejected ${method} ${path} with 400`);
|
|
@@ -1,9 +1,5 @@
|
|
|
1
1
|
import { Effect, Stream } from "effect";
|
|
2
|
-
import {
|
|
3
|
-
|
|
4
|
-
export function waitForClient(activity: ClientActivity) {
|
|
5
|
-
return activity.pipe(Stream.filter(isClientIdle), Stream.take(1), Stream.runDrain);
|
|
6
|
-
}
|
|
2
|
+
import type { ClientActivity } from "@shivaedev/contract/clientActivity.ts";
|
|
7
3
|
|
|
8
4
|
export const nextClientHint = Effect.fnUntraced(function* (activity: ClientActivity) {
|
|
9
5
|
const before = (yield* activity.current).liveHints;
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
import { Cause, Effect, Queue, Stream } from "effect";
|
|
2
|
+
|
|
3
|
+
export function recordedSignals<A, E = never>() {
|
|
4
|
+
const values: A[] = [];
|
|
5
|
+
const subscribers = new Set<Queue.Queue<A, E | Cause.Done>>();
|
|
6
|
+
let ended = false;
|
|
7
|
+
let failure: E | undefined;
|
|
8
|
+
function finish(queue: Queue.Queue<A, E | Cause.Done>) {
|
|
9
|
+
if (failure === undefined) {
|
|
10
|
+
Queue.endUnsafe(queue);
|
|
11
|
+
} else {
|
|
12
|
+
Queue.failCauseUnsafe(queue, Cause.fail(failure));
|
|
13
|
+
}
|
|
14
|
+
}
|
|
15
|
+
return {
|
|
16
|
+
end: (error?: E) => {
|
|
17
|
+
ended = true;
|
|
18
|
+
failure = error;
|
|
19
|
+
for (const queue of subscribers) {
|
|
20
|
+
finish(queue);
|
|
21
|
+
}
|
|
22
|
+
},
|
|
23
|
+
push: (value: A) => {
|
|
24
|
+
values.push(value);
|
|
25
|
+
for (const queue of subscribers) {
|
|
26
|
+
Queue.offerUnsafe(queue, value);
|
|
27
|
+
}
|
|
28
|
+
},
|
|
29
|
+
stream: Stream.callback<A, E>((queue) =>
|
|
30
|
+
Effect.gen(function* () {
|
|
31
|
+
for (const value of values) {
|
|
32
|
+
Queue.offerUnsafe(queue, value);
|
|
33
|
+
}
|
|
34
|
+
if (ended) {
|
|
35
|
+
finish(queue);
|
|
36
|
+
} else {
|
|
37
|
+
subscribers.add(queue);
|
|
38
|
+
yield* Effect.addFinalizer(() => Effect.sync(() => subscribers.delete(queue)));
|
|
39
|
+
}
|
|
40
|
+
}),
|
|
41
|
+
),
|
|
42
|
+
values,
|
|
43
|
+
};
|
|
44
|
+
}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { computeAccessibleName, getRole
|
|
1
|
+
import { computeAccessibleName, getRole } from "dom-accessibility-api";
|
|
2
2
|
import type { ScreenTarget } from "#screenDriver.ts";
|
|
3
3
|
|
|
4
4
|
export function accessibility(element: Element) {
|
|
@@ -24,27 +24,3 @@ export function isRendered(found: HTMLElement) {
|
|
|
24
24
|
}
|
|
25
25
|
return true;
|
|
26
26
|
}
|
|
27
|
-
|
|
28
|
-
export function roleElement(root: HTMLElement, target: Exclude<ScreenTarget, string>) {
|
|
29
|
-
const candidates = Array.from(root.querySelectorAll<HTMLElement>("*"))
|
|
30
|
-
.filter((element) => isRendered(element) && !isInaccessible(element))
|
|
31
|
-
.map((element) => ({ ...accessibility(element), element }))
|
|
32
|
-
.filter(({ role }) => role !== null);
|
|
33
|
-
const matches = candidates.filter(({ role, name }) => {
|
|
34
|
-
if (role !== target.role) {
|
|
35
|
-
return false;
|
|
36
|
-
}
|
|
37
|
-
if (typeof target.name === "string") {
|
|
38
|
-
return name === target.name;
|
|
39
|
-
}
|
|
40
|
-
return new RegExp(target.name.source, target.name.flags).test(name);
|
|
41
|
-
});
|
|
42
|
-
const found = matches[0];
|
|
43
|
-
if (matches.length === 1 && found) {
|
|
44
|
-
return found.element;
|
|
45
|
-
}
|
|
46
|
-
const listing = candidates.map(({ role, name }) => ` - ${role} named ${JSON.stringify(name)}`).join("\n");
|
|
47
|
-
throw new Error(
|
|
48
|
-
`The screen has ${matches.length} matches for ${targetName(target)}.\nhelp: Use a role and name for exactly one visible target.\nCandidates on screen:\n${listing || " (none)"}`,
|
|
49
|
-
);
|
|
50
|
-
}
|
|
@@ -1,9 +1,9 @@
|
|
|
1
|
+
import { screenElements } from "#adapters/screenElements.ts";
|
|
1
2
|
import type { ScreenTarget } from "#screenDriver.ts";
|
|
2
3
|
import { accessibility, targetName } from "./screenAccessibility.ts";
|
|
3
|
-
import { screenElements } from "./screenElements.ts";
|
|
4
4
|
|
|
5
|
-
export function screenReadouts(currentRoot: () => HTMLElement, tell: (line: string) => void) {
|
|
6
|
-
const elements = screenElements(currentRoot);
|
|
5
|
+
export function screenReadouts(currentRoot: () => HTMLElement, tell: (line: string) => void, dialogs = true) {
|
|
6
|
+
const elements = screenElements(currentRoot, dialogs);
|
|
7
7
|
return {
|
|
8
8
|
accessible: (selector: string | Element) => {
|
|
9
9
|
if (typeof selector !== "string") {
|
|
@@ -0,0 +1,105 @@
|
|
|
1
|
+
import { Effect } from "effect";
|
|
2
|
+
import { withLive } from "@shivaedev/test/withLive.ts";
|
|
3
|
+
import type { screenElements } from "#adapters/screenElements.ts";
|
|
4
|
+
import { screenNavigation } from "#adapters/screenNavigation.ts";
|
|
5
|
+
import type { ScreenDriverOptions, ScreenTarget } from "#screenDriver.ts";
|
|
6
|
+
import { targetName } from "./screenAccessibility.ts";
|
|
7
|
+
import { waitForScreen } from "./waitForScreen.ts";
|
|
8
|
+
|
|
9
|
+
type Options = Omit<ScreenDriverOptions, "act" | "root" | "timeoutMs" | "pending"> & {
|
|
10
|
+
readonly act: NonNullable<ScreenDriverOptions["act"]>;
|
|
11
|
+
readonly pending: ScreenDriverOptions["pending"];
|
|
12
|
+
readonly root: () => HTMLElement;
|
|
13
|
+
readonly timeoutMs: number;
|
|
14
|
+
};
|
|
15
|
+
|
|
16
|
+
export function screenWaits(options: Options, elements: ReturnType<typeof screenElements>) {
|
|
17
|
+
const { act, pending, root, tell, timeoutMs } = options;
|
|
18
|
+
function unsettled(limit: number) {
|
|
19
|
+
return new Error(
|
|
20
|
+
`The screen did not settle within ${limit}ms.\nhelp: Release held requests and check the app's pending signal and renderer act adapter.\nScreen: ${root().textContent}`,
|
|
21
|
+
);
|
|
22
|
+
}
|
|
23
|
+
function wait<A>(line: string, read: () => A, timeout: number, expired: () => Effect.Effect<A>) {
|
|
24
|
+
return withLive(
|
|
25
|
+
Effect.sync(() => tell(line)).pipe(
|
|
26
|
+
Effect.andThen(waitForScreen({ act, pending, root }, Effect.try(read))),
|
|
27
|
+
Effect.timeoutOrElse({ duration: timeout, orElse: expired }),
|
|
28
|
+
),
|
|
29
|
+
);
|
|
30
|
+
}
|
|
31
|
+
return {
|
|
32
|
+
find: (target: ScreenTarget, settings: { readonly timeout?: number } = {}) => {
|
|
33
|
+
const limit = settings.timeout ?? timeoutMs;
|
|
34
|
+
return wait(
|
|
35
|
+
`find ${targetName(target)}`,
|
|
36
|
+
() => elements.element(target),
|
|
37
|
+
limit,
|
|
38
|
+
() => {
|
|
39
|
+
const lookup = Effect.sync(() => elements.element(target));
|
|
40
|
+
return pending === undefined ? lookup : lookup.pipe(Effect.andThen(Effect.die(unsettled(limit))));
|
|
41
|
+
},
|
|
42
|
+
);
|
|
43
|
+
},
|
|
44
|
+
findText: (text: string | RegExp, settings: { readonly timeout?: number } = {}) => {
|
|
45
|
+
const name = typeof text === "string" ? JSON.stringify(text) : String(text);
|
|
46
|
+
const limit = settings.timeout ?? timeoutMs;
|
|
47
|
+
return wait(
|
|
48
|
+
`find text ${name}`,
|
|
49
|
+
() => elements.textElement(text),
|
|
50
|
+
limit,
|
|
51
|
+
() =>
|
|
52
|
+
Effect.sync(() => elements.textElement(text)).pipe(
|
|
53
|
+
Effect.andThen(
|
|
54
|
+
Effect.die(new Error(`The screen did not finish waiting for text ${name} within ${limit}ms.\nhelp: Check the app's pending signal.`)),
|
|
55
|
+
),
|
|
56
|
+
),
|
|
57
|
+
);
|
|
58
|
+
},
|
|
59
|
+
gone: (target: ScreenTarget, settings: { readonly timeout?: number } = {}) => {
|
|
60
|
+
const limit = settings.timeout ?? timeoutMs;
|
|
61
|
+
function stillHere() {
|
|
62
|
+
return new Error(
|
|
63
|
+
`The screen did not lose ${targetName(target)} within ${limit}ms.\nhelp: Remove or hide every matching target and complete pending work.`,
|
|
64
|
+
);
|
|
65
|
+
}
|
|
66
|
+
return withLive(
|
|
67
|
+
Effect.sync(() => tell(`wait for ${targetName(target)} to disappear`)).pipe(
|
|
68
|
+
Effect.andThen(
|
|
69
|
+
waitForScreen(
|
|
70
|
+
{ act, pending, root },
|
|
71
|
+
Effect.suspend(() => (elements.matches(target).length === 0 ? Effect.void : Effect.fail(stillHere()))),
|
|
72
|
+
),
|
|
73
|
+
),
|
|
74
|
+
Effect.timeoutOrElse({ duration: limit, orElse: () => Effect.die(stillHere()) }),
|
|
75
|
+
),
|
|
76
|
+
);
|
|
77
|
+
},
|
|
78
|
+
navigatedAway: (prefix: string, settings: { readonly timeout?: number } = {}) => {
|
|
79
|
+
const limit = settings.timeout ?? timeoutMs;
|
|
80
|
+
function timedOut() {
|
|
81
|
+
return Effect.die(
|
|
82
|
+
new Error(
|
|
83
|
+
`The screen did not navigate to ${JSON.stringify(prefix)} within ${limit}ms.\nhelp: Trigger the redirect and check its destination.\nLocation: ${root().ownerDocument.location.href}`,
|
|
84
|
+
),
|
|
85
|
+
);
|
|
86
|
+
}
|
|
87
|
+
return withLive(
|
|
88
|
+
Effect.sync(() => tell(`wait for navigation to ${JSON.stringify(prefix)}`)).pipe(
|
|
89
|
+
Effect.andThen(screenNavigation(root, prefix)),
|
|
90
|
+
Effect.timeoutOrElse({ duration: limit, orElse: timedOut }),
|
|
91
|
+
),
|
|
92
|
+
);
|
|
93
|
+
},
|
|
94
|
+
settle: (settings: { readonly timeoutMs?: number } = {}) => {
|
|
95
|
+
const limit = settings.timeoutMs ?? timeoutMs;
|
|
96
|
+
return withLive(
|
|
97
|
+
Effect.sync(() => tell("wait for the screen's pending work")).pipe(
|
|
98
|
+
Effect.andThen(waitForScreen({ act, pending, root }, Effect.void)),
|
|
99
|
+
Effect.tap(() => Effect.sync(() => tell("the screen has no pending work"))),
|
|
100
|
+
Effect.timeoutOrElse({ duration: limit, orElse: () => Effect.die(unsettled(limit)) }),
|
|
101
|
+
),
|
|
102
|
+
);
|
|
103
|
+
},
|
|
104
|
+
};
|
|
105
|
+
}
|
|
@@ -9,6 +9,7 @@ import { type Genre, genreOf } from "#internal/genre.ts";
|
|
|
9
9
|
import { type AnyEffect, hooked } from "#internal/hooked.ts";
|
|
10
10
|
import type { LooseDefinition, LooseTrait } from "#internal/seed.ts";
|
|
11
11
|
import { start } from "#internal/start.ts";
|
|
12
|
+
import { withWatchedClock } from "#internal/withWatchedClock.ts";
|
|
12
13
|
import { routeOutbound } from "#routeOutbound.ts";
|
|
13
14
|
|
|
14
15
|
type LooseBody = (told: object, context: TestContext) => Generator<AnyEffect, unknown, never> | undefined;
|
|
@@ -64,7 +65,7 @@ export function storyIt(definition: LooseDefinition): LooseIt {
|
|
|
64
65
|
yield* routeOutbound(outbound, { passthrough: definition.outboundPassthrough === true });
|
|
65
66
|
}
|
|
66
67
|
return yield* definition.around?.(effect) ?? effect;
|
|
67
|
-
}).pipe(Effect.provide(TestCrypto.layer(0).pipe(Layer.provide(NodeCrypto.layer)))),
|
|
68
|
+
}).pipe(Effect.provide(TestCrypto.layer(0).pipe(Layer.provide(NodeCrypto.layer))), withWatchedClock),
|
|
68
69
|
clock: definition.clock,
|
|
69
70
|
layer: definition.layer ?? Layer.empty,
|
|
70
71
|
makeHarness: () => Effect.void,
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
import { Effect, Queue, Result, Stream } from "effect";
|
|
2
|
+
import { isClientIdle } from "@shivaedev/contract/clientActivity.ts";
|
|
3
|
+
import { screenMutations } from "#adapters/screenMutations.ts";
|
|
4
|
+
import type { ScreenDriverOptions } from "#screenDriver.ts";
|
|
5
|
+
|
|
6
|
+
type WaitOptions = Required<Pick<ScreenDriverOptions, "act">> & {
|
|
7
|
+
readonly pending: ScreenDriverOptions["pending"];
|
|
8
|
+
readonly root: () => HTMLElement;
|
|
9
|
+
};
|
|
10
|
+
|
|
11
|
+
const observePending = Effect.fnUntraced(function* (pending: ScreenDriverOptions["pending"], changes: Queue.Queue<void>) {
|
|
12
|
+
if (pending === undefined) {
|
|
13
|
+
return Effect.succeed(false);
|
|
14
|
+
}
|
|
15
|
+
if (typeof pending === "function") {
|
|
16
|
+
return Effect.sync(pending);
|
|
17
|
+
}
|
|
18
|
+
let busy = true;
|
|
19
|
+
const states = "current" in pending ? Stream.map(pending, (state) => !isClientIdle(state)) : pending;
|
|
20
|
+
yield* states.pipe(
|
|
21
|
+
Stream.runForEach((value) =>
|
|
22
|
+
Effect.sync(() => {
|
|
23
|
+
busy = value;
|
|
24
|
+
Queue.offerUnsafe(changes, undefined);
|
|
25
|
+
}),
|
|
26
|
+
),
|
|
27
|
+
Effect.forkScoped,
|
|
28
|
+
);
|
|
29
|
+
return "current" in pending ? Effect.map(pending.current, (state) => !isClientIdle(state)) : Effect.sync(() => busy);
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
export const waitForScreen = Effect.fnUntraced(function* <A, E>({ act, pending, root }: WaitOptions, read: Effect.Effect<A, E>) {
|
|
33
|
+
const changes = yield* Queue.sliding<void>(1);
|
|
34
|
+
yield* screenMutations(root(), () => Queue.offerUnsafe(changes, undefined));
|
|
35
|
+
const isBusy = yield* observePending(pending, changes);
|
|
36
|
+
do {
|
|
37
|
+
if (pending !== undefined) {
|
|
38
|
+
yield* Effect.promise(() => act(() => Promise.resolve()));
|
|
39
|
+
}
|
|
40
|
+
if (!(yield* isBusy)) {
|
|
41
|
+
const result = yield* Effect.result(read);
|
|
42
|
+
if (Result.isSuccess(result)) {
|
|
43
|
+
return result.success;
|
|
44
|
+
}
|
|
45
|
+
}
|
|
46
|
+
yield* pending === undefined ? Queue.take(changes) : Effect.promise((signal) => act(() => Effect.runPromise(Queue.take(changes), { signal })));
|
|
47
|
+
} while (true);
|
|
48
|
+
}, Effect.scoped);
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
import { Clock, Effect } from "effect";
|
|
2
|
+
import { watchedClock } from "#watchedClock.ts";
|
|
3
|
+
|
|
4
|
+
export function withWatchedClock<A, E, R>(effect: Effect.Effect<A, E, R>) {
|
|
5
|
+
return Clock.clockWith((clock) =>
|
|
6
|
+
"adjust" in clock ? Effect.flatMap(watchedClock, (watched) => Effect.provideService(effect, Clock.Clock, watched)) : effect,
|
|
7
|
+
);
|
|
8
|
+
}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
import { createInterface } from "node:readline";
|
|
2
|
+
import type { Readable } from "node:stream";
|
|
3
|
+
import { Effect } from "effect";
|
|
4
|
+
import { recordedSignals } from "#internal/recordedSignals.ts";
|
|
5
|
+
import { type UntilOptions, until } from "#until.ts";
|
|
6
|
+
|
|
7
|
+
export const lineSignals = Effect.fnUntraced(function* (output: Readable) {
|
|
8
|
+
const signals = recordedSignals<string, Error>();
|
|
9
|
+
yield* Effect.acquireRelease(
|
|
10
|
+
Effect.sync(() => {
|
|
11
|
+
const reader = createInterface({ crlfDelay: Number.POSITIVE_INFINITY, input: output });
|
|
12
|
+
reader.on("line", signals.push);
|
|
13
|
+
reader.once("close", () => signals.end());
|
|
14
|
+
reader.on("error", signals.end);
|
|
15
|
+
return reader;
|
|
16
|
+
}),
|
|
17
|
+
(reader) => Effect.sync(() => reader.close()),
|
|
18
|
+
);
|
|
19
|
+
return {
|
|
20
|
+
get lines(): readonly string[] {
|
|
21
|
+
return signals.values.slice();
|
|
22
|
+
},
|
|
23
|
+
untilLine: (matches: (line: string) => boolean, options: UntilOptions) => until(signals.stream, matches, options),
|
|
24
|
+
};
|
|
25
|
+
});
|
|
@@ -3,6 +3,8 @@ import { Effect } from "effect";
|
|
|
3
3
|
import * as HttpStatus from "effect/http/HttpStatus";
|
|
4
4
|
import { loopbackServer } from "#internal/loopback.ts";
|
|
5
5
|
import { otlpReadout } from "#internal/otlpReadout.ts";
|
|
6
|
+
import { recordedSignals } from "#internal/recordedSignals.ts";
|
|
7
|
+
import { type UntilOptions, until } from "#until.ts";
|
|
6
8
|
|
|
7
9
|
export type OtlpSpan = ReturnType<typeof otlpReadout>[number];
|
|
8
10
|
export interface OtlpExport {
|
|
@@ -17,7 +19,13 @@ export interface OtlpReceiverOptions {
|
|
|
17
19
|
readonly status?: number | ((attempt: number) => number | undefined);
|
|
18
20
|
}
|
|
19
21
|
|
|
20
|
-
async function receive(
|
|
22
|
+
async function receive(
|
|
23
|
+
request: IncomingMessage,
|
|
24
|
+
response: ServerResponse,
|
|
25
|
+
requests: OtlpExport[],
|
|
26
|
+
record: (span: OtlpSpan) => void,
|
|
27
|
+
options: OtlpReceiverOptions,
|
|
28
|
+
) {
|
|
21
29
|
try {
|
|
22
30
|
const chunks: Buffer[] = [];
|
|
23
31
|
for await (const chunk of request) {
|
|
@@ -34,7 +42,9 @@ async function receive(request: IncomingMessage, response: ServerResponse, reque
|
|
|
34
42
|
response.writeHead(HttpStatus.fromLiteral("UnsupportedMediaType")).end();
|
|
35
43
|
return;
|
|
36
44
|
}
|
|
37
|
-
|
|
45
|
+
for (const span of otlpReadout(body, contentType)) {
|
|
46
|
+
record(span);
|
|
47
|
+
}
|
|
38
48
|
const status = typeof options.status === "function" ? options.status(requests.length) : (options.status ?? HttpStatus.fromLiteral("OK"));
|
|
39
49
|
if (status === undefined) {
|
|
40
50
|
return;
|
|
@@ -52,13 +62,18 @@ async function receive(request: IncomingMessage, response: ServerResponse, reque
|
|
|
52
62
|
|
|
53
63
|
export const otlpReceiver = Effect.fnUntraced(function* (options: OtlpReceiverOptions = {}) {
|
|
54
64
|
const requests: OtlpExport[] = [];
|
|
55
|
-
const
|
|
56
|
-
const server = createServer((request, response) => receive(request, response, requests,
|
|
65
|
+
const signals = recordedSignals<OtlpSpan>();
|
|
66
|
+
const server = createServer((request, response) => receive(request, response, requests, signals.push, options));
|
|
57
67
|
const url = yield* loopbackServer(server);
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
68
|
+
yield* Effect.addFinalizer(() => Effect.sync(() => signals.end()));
|
|
69
|
+
return {
|
|
70
|
+
get requests(): readonly OtlpExport[] {
|
|
71
|
+
return requests;
|
|
72
|
+
},
|
|
73
|
+
get spans(): readonly OtlpSpan[] {
|
|
74
|
+
return signals.values;
|
|
75
|
+
},
|
|
76
|
+
untilSpan: (matches: (span: OtlpSpan) => boolean, wait: UntilOptions) => until(signals.stream, matches, wait),
|
|
61
77
|
url,
|
|
62
78
|
};
|
|
63
|
-
return receiver;
|
|
64
79
|
});
|
package/src/server/outcomes.ts
CHANGED
|
@@ -1,21 +1,30 @@
|
|
|
1
1
|
import { Effect } from "effect";
|
|
2
2
|
import { type DeeplyAllowMatchers, expect } from "vitest";
|
|
3
|
+
import type { NumericBound } from "#adapters/outcomeMatchers.ts";
|
|
3
4
|
|
|
4
5
|
type AnyReadout = Effect.Effect<unknown, unknown, unknown>;
|
|
6
|
+
type NativeMatcher = Exclude<DeeplyAllowMatchers<number>, number>;
|
|
7
|
+
type Expected<T> =
|
|
8
|
+
| NativeMatcher
|
|
9
|
+
| (T extends readonly unknown[]
|
|
10
|
+
? { readonly [TKey in keyof T]: Expected<T[TKey]> }
|
|
11
|
+
: T extends object
|
|
12
|
+
? { readonly [TKey in keyof T]?: Expected<T[TKey]> }
|
|
13
|
+
: T | (T extends number ? NumericBound : never));
|
|
5
14
|
|
|
6
15
|
export const outcomes = Effect.fn("Story.outcomes")(check);
|
|
7
16
|
|
|
8
|
-
function check<TReadouts extends
|
|
17
|
+
function check<TReadouts extends readonly AnyReadout[]>(
|
|
9
18
|
rows: {
|
|
10
|
-
readonly [TKey in keyof TReadouts]: readonly [TReadouts[TKey],
|
|
19
|
+
readonly [TKey in keyof TReadouts]: readonly [string, () => TReadouts[TKey], Expected<Effect.Success<NoInfer<TReadouts[TKey]>>>];
|
|
11
20
|
},
|
|
12
|
-
): Effect.fn.Return<void, Effect.Error<TReadouts[
|
|
13
|
-
function* check(rows:
|
|
14
|
-
const actual: Record<string, unknown> =
|
|
15
|
-
const expected: Record<string, unknown> =
|
|
16
|
-
for (const [label,
|
|
17
|
-
actual[label]
|
|
18
|
-
expected[label]
|
|
21
|
+
): Effect.fn.Return<void, Effect.Error<TReadouts[number]>, Effect.Services<TReadouts[number]>>;
|
|
22
|
+
function* check(rows: readonly (readonly [string, () => AnyReadout, unknown])[]) {
|
|
23
|
+
const actual: Record<string, unknown>[] = [];
|
|
24
|
+
const expected: Record<string, unknown>[] = [];
|
|
25
|
+
for (const [label, readout, value] of rows) {
|
|
26
|
+
actual.push({ [label]: yield* Effect.suspend(readout) });
|
|
27
|
+
expected.push({ [label]: value });
|
|
19
28
|
}
|
|
20
|
-
expect(actual).
|
|
29
|
+
expect(actual).toMatchObject(expected);
|
|
21
30
|
}
|