@shivaedev/test-story 0.22.0 → 0.24.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 +40 -0
- package/README.md +252 -213
- package/dist/server/domFetch.d.ts +6 -1
- package/dist/server/domFetch.d.ts.map +1 -1
- package/dist/server/domFetch.js +3 -3
- package/dist/server/domFetch.js.map +1 -1
- package/dist/server/forwardingProxy.d.ts +2 -0
- package/dist/server/forwardingProxy.d.ts.map +1 -1
- package/dist/server/forwardingProxy.js +65 -6
- package/dist/server/forwardingProxy.js.map +1 -1
- package/dist/server/internal/adapters/memberFetch.d.ts +3 -0
- package/dist/server/internal/adapters/memberFetch.d.ts.map +1 -0
- package/dist/server/internal/adapters/memberFetch.js +68 -0
- package/dist/server/internal/adapters/memberFetch.js.map +1 -0
- package/dist/server/internal/screenElements.d.ts +1 -0
- package/dist/server/internal/screenElements.d.ts.map +1 -1
- package/dist/server/internal/screenElements.js +11 -0
- package/dist/server/internal/screenElements.js.map +1 -1
- package/dist/server/memberScreens.d.ts +20 -0
- package/dist/server/memberScreens.d.ts.map +1 -0
- package/dist/server/memberScreens.js +40 -0
- package/dist/server/memberScreens.js.map +1 -0
- package/dist/server/screenDriver.d.ts +3 -2
- package/dist/server/screenDriver.d.ts.map +1 -1
- package/dist/server/screenDriver.js +15 -3
- package/dist/server/screenDriver.js.map +1 -1
- package/dist/server/seedCookies.d.ts +2 -1
- package/dist/server/seedCookies.d.ts.map +1 -1
- package/dist/server/seedCookies.js +4 -4
- package/dist/server/seedCookies.js.map +1 -1
- package/package.json +11 -11
- package/src/server/domFetch.ts +6 -3
- package/src/server/forwardingProxy.ts +81 -23
- package/src/server/internal/adapters/memberFetch.ts +67 -0
- package/src/server/internal/screenElements.ts +11 -0
- package/src/server/memberScreens.ts +61 -0
- package/src/server/screenDriver.ts +18 -5
- package/src/server/seedCookies.ts +4 -4
|
@@ -1,5 +1,6 @@
|
|
|
1
|
-
import { createServer, type RequestListener, request } from "node:http";
|
|
1
|
+
import { createServer, type IncomingMessage, type RequestListener, request } from "node:http";
|
|
2
2
|
import { isIP } from "node:net";
|
|
3
|
+
import type { Duplex } from "node:stream";
|
|
3
4
|
import { Effect } from "effect";
|
|
4
5
|
import * as HttpStatus from "effect/http/HttpStatus";
|
|
5
6
|
import { loopbackServer } from "#internal/loopback.ts";
|
|
@@ -16,26 +17,30 @@ export const forwardingProxy = Effect.fnUntraced(function* (upstream: string, op
|
|
|
16
17
|
Effect.mapError((cause) => new Error(`Cannot acquire forwarding proxy with local address ${options.localAddress}`, { cause })),
|
|
17
18
|
);
|
|
18
19
|
}
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
{
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
.join(", "),
|
|
29
|
-
...options.headers,
|
|
30
|
-
},
|
|
31
|
-
localAddress: options.localAddress,
|
|
32
|
-
method: incoming.method,
|
|
33
|
-
},
|
|
34
|
-
(result) => {
|
|
35
|
-
response.writeHead(result.statusCode ?? HttpStatus.fromLiteral("BadGateway"), result.headers);
|
|
36
|
-
result.pipe(response);
|
|
20
|
+
function requestOptions(incoming: IncomingMessage) {
|
|
21
|
+
return {
|
|
22
|
+
family: options.localAddress === undefined ? undefined : isIP(options.localAddress),
|
|
23
|
+
headers: {
|
|
24
|
+
...incoming.headers,
|
|
25
|
+
"x-forwarded-for": [incoming.headers["x-forwarded-for"], ...(options.forwardedHops ?? [incoming.socket.remoteAddress])]
|
|
26
|
+
.filter(Boolean)
|
|
27
|
+
.join(", "),
|
|
28
|
+
...options.headers,
|
|
37
29
|
},
|
|
38
|
-
|
|
30
|
+
localAddress: options.localAddress,
|
|
31
|
+
method: incoming.method,
|
|
32
|
+
};
|
|
33
|
+
}
|
|
34
|
+
let offline = false;
|
|
35
|
+
const forward: RequestListener = (incoming, response) => {
|
|
36
|
+
if (offline) {
|
|
37
|
+
incoming.destroy();
|
|
38
|
+
return;
|
|
39
|
+
}
|
|
40
|
+
const outgoing = request(`${upstream}${incoming.url}`, requestOptions(incoming), (result) => {
|
|
41
|
+
response.writeHead(result.statusCode ?? HttpStatus.fromLiteral("BadGateway"), result.headers);
|
|
42
|
+
result.pipe(response);
|
|
43
|
+
});
|
|
39
44
|
outgoing.on("error", (error) => {
|
|
40
45
|
if (response.headersSent) {
|
|
41
46
|
response.destroy(error);
|
|
@@ -46,7 +51,60 @@ export const forwardingProxy = Effect.fnUntraced(function* (upstream: string, op
|
|
|
46
51
|
response.on("close", () => outgoing.destroy());
|
|
47
52
|
incoming.pipe(outgoing);
|
|
48
53
|
};
|
|
49
|
-
const
|
|
50
|
-
|
|
51
|
-
|
|
54
|
+
const sockets = new Set<Duplex>();
|
|
55
|
+
function server() {
|
|
56
|
+
return createServer(forward)
|
|
57
|
+
.on("connection", (socket) => {
|
|
58
|
+
sockets.add(socket);
|
|
59
|
+
socket.on("close", () => sockets.delete(socket));
|
|
60
|
+
})
|
|
61
|
+
.on("upgrade", (incoming, downstream, head) => {
|
|
62
|
+
if (offline) {
|
|
63
|
+
downstream.destroy();
|
|
64
|
+
return;
|
|
65
|
+
}
|
|
66
|
+
const outgoing = request(`${upstream}${incoming.url}`, requestOptions(incoming));
|
|
67
|
+
outgoing.on("upgrade", (result, upstreamSocket, upstreamHead) => {
|
|
68
|
+
downstream.write(`HTTP/1.1 ${result.statusCode} ${result.statusMessage}\r\n`);
|
|
69
|
+
for (let index = 0; index < result.rawHeaders.length; index += 2) {
|
|
70
|
+
downstream.write(`${result.rawHeaders[index]}: ${result.rawHeaders[index + 1]}\r\n`);
|
|
71
|
+
}
|
|
72
|
+
downstream.write("\r\n");
|
|
73
|
+
downstream.write(upstreamHead);
|
|
74
|
+
upstreamSocket.write(head);
|
|
75
|
+
downstream.pipe(upstreamSocket).pipe(downstream);
|
|
76
|
+
downstream.on("close", () => upstreamSocket.destroy());
|
|
77
|
+
upstreamSocket.on("error", () => downstream.destroy());
|
|
78
|
+
});
|
|
79
|
+
outgoing.on("response", (result) => {
|
|
80
|
+
downstream.end(`HTTP/1.1 ${result.statusCode} ${result.statusMessage}\r\nConnection: close\r\n\r\n`);
|
|
81
|
+
result.resume();
|
|
82
|
+
});
|
|
83
|
+
outgoing.on("error", () => downstream.destroy());
|
|
84
|
+
downstream.on("error", () => outgoing.destroy());
|
|
85
|
+
downstream.on("close", () => outgoing.destroy());
|
|
86
|
+
outgoing.end();
|
|
87
|
+
});
|
|
88
|
+
}
|
|
89
|
+
const url = yield* loopbackServer(server());
|
|
90
|
+
yield* loopbackServer(server(), { host: "::1", port: Number(new URL(url).port) });
|
|
91
|
+
yield* Effect.addFinalizer(() =>
|
|
92
|
+
Effect.sync(() => {
|
|
93
|
+
for (const socket of sockets) {
|
|
94
|
+
socket.destroy();
|
|
95
|
+
}
|
|
96
|
+
}),
|
|
97
|
+
);
|
|
98
|
+
return {
|
|
99
|
+
disconnect: () => {
|
|
100
|
+
offline = true;
|
|
101
|
+
for (const socket of sockets) {
|
|
102
|
+
socket.destroy();
|
|
103
|
+
}
|
|
104
|
+
},
|
|
105
|
+
resume: () => {
|
|
106
|
+
offline = false;
|
|
107
|
+
},
|
|
108
|
+
url,
|
|
109
|
+
};
|
|
52
110
|
});
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
import type { Response as BrowserResponse, BrowserWindow } from "happy-dom";
|
|
2
|
+
|
|
3
|
+
function responseBody(response: BrowserResponse, release: () => void) {
|
|
4
|
+
if (response.body === null) {
|
|
5
|
+
release();
|
|
6
|
+
return null;
|
|
7
|
+
}
|
|
8
|
+
const reader = response.body.getReader();
|
|
9
|
+
return new ReadableStream<Uint8Array>({
|
|
10
|
+
async cancel(reason) {
|
|
11
|
+
release();
|
|
12
|
+
await reader.cancel(reason);
|
|
13
|
+
},
|
|
14
|
+
async pull(controller) {
|
|
15
|
+
try {
|
|
16
|
+
const next = await reader.read();
|
|
17
|
+
if (next.done) {
|
|
18
|
+
release();
|
|
19
|
+
controller.close();
|
|
20
|
+
} else {
|
|
21
|
+
controller.enqueue(next.value);
|
|
22
|
+
}
|
|
23
|
+
} catch (error) {
|
|
24
|
+
release();
|
|
25
|
+
controller.error(error);
|
|
26
|
+
}
|
|
27
|
+
},
|
|
28
|
+
});
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export function memberFetch(browser: BrowserWindow): typeof globalThis.fetch {
|
|
32
|
+
return async (input, init) => {
|
|
33
|
+
const request = new Request(input, init);
|
|
34
|
+
const controller = new browser.AbortController();
|
|
35
|
+
function abort() {
|
|
36
|
+
controller.abort(request.signal.reason);
|
|
37
|
+
}
|
|
38
|
+
function release() {
|
|
39
|
+
request.signal.removeEventListener("abort", abort);
|
|
40
|
+
}
|
|
41
|
+
request.signal.addEventListener("abort", abort, { once: true });
|
|
42
|
+
if (request.signal.aborted) {
|
|
43
|
+
abort();
|
|
44
|
+
}
|
|
45
|
+
try {
|
|
46
|
+
const response = await browser.fetch(request.url, {
|
|
47
|
+
body: request.body === null ? null : await request.arrayBuffer(),
|
|
48
|
+
credentials: request.credentials,
|
|
49
|
+
headers: [...request.headers],
|
|
50
|
+
method: request.method,
|
|
51
|
+
redirect: request.redirect,
|
|
52
|
+
signal: controller.signal,
|
|
53
|
+
});
|
|
54
|
+
const result = new Response(responseBody(response, release), {
|
|
55
|
+
headers: [...response.headers],
|
|
56
|
+
status: response.status,
|
|
57
|
+
statusText: response.statusText,
|
|
58
|
+
});
|
|
59
|
+
Object.defineProperty(result, "url", { value: response.url });
|
|
60
|
+
Object.defineProperty(result, "redirected", { value: response.redirected });
|
|
61
|
+
return result;
|
|
62
|
+
} catch (error) {
|
|
63
|
+
release();
|
|
64
|
+
throw error;
|
|
65
|
+
}
|
|
66
|
+
};
|
|
67
|
+
}
|
|
@@ -35,6 +35,16 @@ export function screenElements(root: () => HTMLElement) {
|
|
|
35
35
|
throw new Error(`The screen's ${targetName(selector)} is disabled.\nhelp: Wait for the app to enable the control before acting on it.`);
|
|
36
36
|
}
|
|
37
37
|
}
|
|
38
|
+
function text(found: HTMLElement): string {
|
|
39
|
+
const walker = found.ownerDocument.createTreeWalker(found, NodeFilter.SHOW_TEXT);
|
|
40
|
+
const parts: string[] = [];
|
|
41
|
+
for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) {
|
|
42
|
+
if (node.parentElement instanceof HTMLElement && isRendered(node.parentElement)) {
|
|
43
|
+
parts.push(node.textContent ?? "");
|
|
44
|
+
}
|
|
45
|
+
}
|
|
46
|
+
return parts.join("");
|
|
47
|
+
}
|
|
38
48
|
return {
|
|
39
49
|
element,
|
|
40
50
|
enabled,
|
|
@@ -60,5 +70,6 @@ export function screenElements(root: () => HTMLElement) {
|
|
|
60
70
|
},
|
|
61
71
|
input,
|
|
62
72
|
rendered,
|
|
73
|
+
text,
|
|
63
74
|
};
|
|
64
75
|
}
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
import { Effect, Option, type Scope } from "effect";
|
|
2
|
+
import * as AtomRegistry from "effect/reactivity/AtomRegistry";
|
|
3
|
+
import { GlobalWindow } from "happy-dom";
|
|
4
|
+
import { domFetch } from "#domFetch.ts";
|
|
5
|
+
import { memberFetch } from "#internal/adapters/memberFetch.ts";
|
|
6
|
+
import { documentTransport } from "#internal/documentTransport.ts";
|
|
7
|
+
import { type DomCookie, seedCookies } from "#seedCookies.ts";
|
|
8
|
+
|
|
9
|
+
export interface MemberScreen {
|
|
10
|
+
readonly fetch: typeof globalThis.fetch;
|
|
11
|
+
readonly name: string;
|
|
12
|
+
readonly registry: AtomRegistry.AtomRegistry;
|
|
13
|
+
readonly root: HTMLDivElement;
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
export function memberScreens<E, R, TVerbs>(options: {
|
|
17
|
+
readonly baseUrl: string;
|
|
18
|
+
readonly mount: (member: MemberScreen) => Effect.Effect<void, E, R | Scope.Scope>;
|
|
19
|
+
readonly verbs: (member: MemberScreen, tell: (line: string) => void) => TVerbs;
|
|
20
|
+
}) {
|
|
21
|
+
const members = new Map<string, MemberScreen>();
|
|
22
|
+
return {
|
|
23
|
+
open: Effect.fnUntraced(function* (name: string, cookies: readonly DomCookie[]) {
|
|
24
|
+
const browser = yield* Effect.acquireRelease(
|
|
25
|
+
Effect.sync(() => new GlobalWindow({ url: options.baseUrl })),
|
|
26
|
+
(target) => Effect.promise(() => target.happyDOM.abort()).pipe(Effect.andThen(Effect.sync(() => target.close()))),
|
|
27
|
+
);
|
|
28
|
+
browser.happyDOM.settings.fetch.interceptor = documentTransport(globalThis.fetch);
|
|
29
|
+
yield* seedCookies(cookies, browser);
|
|
30
|
+
const member = yield* Effect.acquireRelease(
|
|
31
|
+
Effect.sync(() => {
|
|
32
|
+
const root = document.createElement("div");
|
|
33
|
+
document.body.append(root);
|
|
34
|
+
return {
|
|
35
|
+
fetch: domFetch(options.baseUrl, { fetch: memberFetch(browser), location: browser.location }),
|
|
36
|
+
name,
|
|
37
|
+
registry: AtomRegistry.make(),
|
|
38
|
+
root,
|
|
39
|
+
};
|
|
40
|
+
}),
|
|
41
|
+
({ registry, root }) =>
|
|
42
|
+
Effect.sync(() => {
|
|
43
|
+
members.delete(name);
|
|
44
|
+
registry.dispose();
|
|
45
|
+
root.remove();
|
|
46
|
+
}),
|
|
47
|
+
);
|
|
48
|
+
yield* options.mount(member);
|
|
49
|
+
members.set(name, member);
|
|
50
|
+
}),
|
|
51
|
+
verbs: (tell: (line: string) => void) => ({
|
|
52
|
+
as: (name: string) => {
|
|
53
|
+
const member = Option.getOrThrowWith(
|
|
54
|
+
Option.fromUndefinedOr(members.get(name)),
|
|
55
|
+
() => new Error(`No screen is open for ${JSON.stringify(name)}.\nhelp: Open this member in a story trait before using as(name).`),
|
|
56
|
+
);
|
|
57
|
+
return options.verbs(member, (line) => tell(`${name}: ${line}`));
|
|
58
|
+
},
|
|
59
|
+
}),
|
|
60
|
+
};
|
|
61
|
+
}
|
|
@@ -18,17 +18,30 @@ export class MissingScreenPending extends Data.TaggedError("MissingScreenPending
|
|
|
18
18
|
"Cannot settle the screen without the pending option.\nhelp: Supply pending: () => boolean that reads the application's pending work and stays true until its resulting screen work is ready to render.";
|
|
19
19
|
}
|
|
20
20
|
|
|
21
|
-
export type ScreenDriver<E = never> = Omit<ReturnType<typeof
|
|
21
|
+
export type ScreenDriver<E = never> = Omit<ReturnType<typeof makeScreenActions>, "settle"> & {
|
|
22
22
|
settle: (options?: { readonly timeoutMs?: number }) => Effect.Effect<void, E>;
|
|
23
|
+
within: (container: ScreenTarget | HTMLElement) => ScreenDriver<E>;
|
|
23
24
|
};
|
|
24
25
|
|
|
25
26
|
export function screenDriver(options: ScreenDriverOptions & { readonly pending: () => boolean }): ScreenDriver;
|
|
26
27
|
export function screenDriver(options: ScreenDriverOptions): ScreenDriver<MissingScreenPending>;
|
|
27
|
-
export function screenDriver(options: ScreenDriverOptions) {
|
|
28
|
-
|
|
28
|
+
export function screenDriver(options: ScreenDriverOptions): ScreenDriver<MissingScreenPending> {
|
|
29
|
+
const suppliedRoot = options.root;
|
|
30
|
+
const root = typeof suppliedRoot === "function" ? suppliedRoot : () => suppliedRoot;
|
|
31
|
+
const elements = screenElements(root);
|
|
32
|
+
return {
|
|
33
|
+
...makeScreenActions(options),
|
|
34
|
+
within: (container) => {
|
|
35
|
+
function scopedRoot() {
|
|
36
|
+
return container instanceof HTMLElement ? elements.rendered(container, container.tagName.toLowerCase()) : elements.element(container);
|
|
37
|
+
}
|
|
38
|
+
scopedRoot();
|
|
39
|
+
return screenDriver({ ...options, root: scopedRoot });
|
|
40
|
+
},
|
|
41
|
+
};
|
|
29
42
|
}
|
|
30
43
|
|
|
31
|
-
function
|
|
44
|
+
function makeScreenActions({ root, pending, tell, act = (action) => action(), timeoutMs = 3000 }: ScreenDriverOptions) {
|
|
32
45
|
const currentRoot = typeof root === "function" ? root : () => root;
|
|
33
46
|
const elements = screenElements(currentRoot);
|
|
34
47
|
function perform(line: string, action: () => void) {
|
|
@@ -101,7 +114,7 @@ function makeScreenDriver({ root, pending, tell, act = (action) => action(), tim
|
|
|
101
114
|
settle,
|
|
102
115
|
submit: (selector: ScreenTarget = "form") => perform(`submit ${targetName(selector)}`, () => elements.form(selector).requestSubmit()),
|
|
103
116
|
text: (selector?: ScreenTarget) => {
|
|
104
|
-
const text = (selector === undefined ? elements.rendered(currentRoot(), "root") : elements.element(selector))
|
|
117
|
+
const text = elements.text(selector === undefined ? elements.rendered(currentRoot(), "root") : elements.element(selector));
|
|
105
118
|
tell(`read ${selector === undefined ? "the screen" : targetName(selector)}: ${JSON.stringify(text)}`);
|
|
106
119
|
return text;
|
|
107
120
|
},
|
|
@@ -15,18 +15,18 @@ export interface DomCookie {
|
|
|
15
15
|
|
|
16
16
|
const sameSites = { Lax: CookieSameSiteEnum.lax, None: CookieSameSiteEnum.none, Strict: CookieSameSiteEnum.strict };
|
|
17
17
|
|
|
18
|
-
export const seedCookies = Effect.fnUntraced(function* (cookies: readonly DomCookie[]) {
|
|
19
|
-
if (!(
|
|
18
|
+
export const seedCookies = Effect.fnUntraced(function* (cookies: readonly DomCookie[], target: Window | BrowserWindow = window) {
|
|
19
|
+
if (!(target instanceof BrowserWindow)) {
|
|
20
20
|
return yield* Effect.die("Cookie preconditions need a happy-dom window.\nhelp: Use test-story's DOM environment before seeding cookies.");
|
|
21
21
|
}
|
|
22
|
-
const context = new WindowBrowserContext(
|
|
22
|
+
const context = new WindowBrowserContext(target).getBrowserContext();
|
|
23
23
|
if (context === null) {
|
|
24
24
|
return yield* Effect.die("Cannot seed cookies after the document has closed.");
|
|
25
25
|
}
|
|
26
26
|
context.cookieContainer.addCookies(
|
|
27
27
|
cookies.map((cookie) => ({
|
|
28
28
|
key: cookie.name,
|
|
29
|
-
"originURL": new URL(
|
|
29
|
+
"originURL": new URL(target.location.href),
|
|
30
30
|
value: cookie.value,
|
|
31
31
|
...(cookie.domain === undefined ? {} : { domain: cookie.domain }),
|
|
32
32
|
...(cookie.path === undefined ? {} : { path: cookie.path }),
|