@cevek/screentest 0.5.0 → 0.6.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/README.md +7 -3
- package/dist/global-setup.js +106 -53
- package/dist/index.js +69 -32
- package/dist/templates/Dockerfile.firefox-server +1 -1
- package/dist/templates/idle-proxy.mjs +88 -0
- package/dist/templates/launch-server.mjs +36 -11
- package/package.json +2 -1
package/README.md
CHANGED
|
@@ -34,9 +34,13 @@ APP_URL=http://localhost:5050 npx vitest run --config vitest.screentest.config.t
|
|
|
34
34
|
> to your package.json scripts so you can just `npm run screentest`.
|
|
35
35
|
|
|
36
36
|
The daemon lives outside your project — one container serves every
|
|
37
|
-
project on your machine. It listens on `ws://localhost:5180
|
|
38
|
-
~
|
|
39
|
-
`
|
|
37
|
+
project on your machine. It listens on `ws://localhost:5180` and holds
|
|
38
|
+
~300–450MB RAM while up. It stops itself after 3 minutes without a
|
|
39
|
+
connected client (`SCREENTEST_DAEMON_IDLE_SECONDS`: minimum `10`, `0` =
|
|
40
|
+
never, not a plain number = `180`) and the
|
|
41
|
+
next test run starts it again; a running test run keeps it alive.
|
|
42
|
+
Daemons started before 0.6 never stop on their own — after upgrading, run
|
|
43
|
+
`screentest stop` once.
|
|
40
44
|
|
|
41
45
|
Your **tests run natively on the host** (your normal vitest + TS + path
|
|
42
46
|
aliases + watch mode); only the Firefox rendering happens in the
|
package/dist/global-setup.js
CHANGED
|
@@ -17,13 +17,16 @@ import { request } from "http";
|
|
|
17
17
|
import { dirname, resolve } from "path";
|
|
18
18
|
import { fileURLToPath } from "url";
|
|
19
19
|
var IMAGE_NAME = "cevek/screentest-firefox";
|
|
20
|
-
var IMAGE_TAG = "pw-1.60.0";
|
|
20
|
+
var IMAGE_TAG = "pw-1.60.0-r2";
|
|
21
|
+
var PRE_IDLE_STOP_IMAGE = `${IMAGE_NAME}:pw-1.60.0`;
|
|
21
22
|
var FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_TAG}`;
|
|
22
23
|
var CONTAINER_NAME = "screentest-firefox";
|
|
23
24
|
var PORT = 5180;
|
|
24
25
|
var WS_PATH = "screentest-firefox";
|
|
25
26
|
var WS_ENDPOINT = `ws://localhost:${PORT}/${WS_PATH}`;
|
|
26
27
|
var START_TIMEOUT_MS = 3e4;
|
|
28
|
+
var READY_TIMEOUT_MS = 15e3;
|
|
29
|
+
var IDLE_ENV = "SCREENTEST_DAEMON_IDLE_SECONDS";
|
|
27
30
|
function run(cmd, argv) {
|
|
28
31
|
return new Promise((resolveExit) => {
|
|
29
32
|
const p = spawn(cmd, argv, { stdio: "inherit" });
|
|
@@ -34,20 +37,25 @@ function run(cmd, argv) {
|
|
|
34
37
|
function daemonState() {
|
|
35
38
|
const ps = spawnSync(
|
|
36
39
|
"docker",
|
|
37
|
-
["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}}"],
|
|
40
|
+
["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}} {{.ID}}"],
|
|
38
41
|
{ stdio: "pipe", encoding: "utf8" }
|
|
39
42
|
);
|
|
40
43
|
if (ps.error) return { state: "no-docker", reason: ps.error.message };
|
|
41
44
|
if (ps.status !== 0) return { state: "no-docker", reason: ps.stderr.trim() };
|
|
42
|
-
const [status = "", image = ""] = ps.stdout.trim().split(" ");
|
|
43
|
-
if (status === "running") return { state: "running", image: image.trim() };
|
|
44
|
-
if (status === "paused") return { state: "paused" };
|
|
45
|
+
const [status = "", image = "", id = ""] = ps.stdout.trim().split(" ");
|
|
46
|
+
if (status === "running") return { state: "running", image: image.trim(), id: id.trim() };
|
|
47
|
+
if (status === "paused") return { state: "paused", id: id.trim() };
|
|
45
48
|
if (status === "created" || status === "restarting" || status === "removing") {
|
|
46
49
|
return { state: "transitional", status };
|
|
47
50
|
}
|
|
51
|
+
const staleId = id.trim();
|
|
48
52
|
const img = spawnSync("docker", ["image", "inspect", FULL_IMAGE], { stdio: "pipe" });
|
|
49
|
-
if (img.status !== 0) return { state: "missing-image" };
|
|
50
|
-
return { state: "stopped" };
|
|
53
|
+
if (img.status !== 0) return { state: "missing-image", staleId };
|
|
54
|
+
return { state: "stopped", staleId };
|
|
55
|
+
}
|
|
56
|
+
function sameRunningContainer(id) {
|
|
57
|
+
const s = daemonState();
|
|
58
|
+
return s.state === "running" && s.id === id;
|
|
51
59
|
}
|
|
52
60
|
function resolveTemplatesDir() {
|
|
53
61
|
const here = dirname(fileURLToPath(import.meta.url));
|
|
@@ -82,7 +90,13 @@ async function buildImage() {
|
|
|
82
90
|
}
|
|
83
91
|
function probeServer() {
|
|
84
92
|
return new Promise((resolveProbe) => {
|
|
85
|
-
const req = request({
|
|
93
|
+
const req = request({
|
|
94
|
+
host: "127.0.0.1",
|
|
95
|
+
port: PORT,
|
|
96
|
+
path: `/${WS_PATH}`,
|
|
97
|
+
timeout: 1e3,
|
|
98
|
+
agent: false
|
|
99
|
+
});
|
|
86
100
|
req.once("response", (res) => {
|
|
87
101
|
res.resume();
|
|
88
102
|
resolveProbe(true);
|
|
@@ -92,14 +106,6 @@ function probeServer() {
|
|
|
92
106
|
req.end();
|
|
93
107
|
});
|
|
94
108
|
}
|
|
95
|
-
async function waitForReady(timeoutMs = 1e4) {
|
|
96
|
-
const start = Date.now();
|
|
97
|
-
while (Date.now() - start < timeoutMs) {
|
|
98
|
-
if (await probeServer()) return true;
|
|
99
|
-
await sleep(150);
|
|
100
|
-
}
|
|
101
|
-
return false;
|
|
102
|
-
}
|
|
103
109
|
function sleep(ms) {
|
|
104
110
|
return new Promise((r) => setTimeout(r, ms));
|
|
105
111
|
}
|
|
@@ -122,35 +128,57 @@ container (${FULL_IMAGE}). Start Docker, then re-run.
|
|
|
122
128
|
`screentest-firefox daemon is running, but on a different image:
|
|
123
129
|
running: ${s.image}
|
|
124
130
|
this @cevek/screentest wants: ${FULL_IMAGE}
|
|
125
|
-
|
|
131
|
+
` + (s.image === PRE_IDLE_STOP_IMAGE ? ` (daemons from @cevek/screentest < 0.6 never stop on their own)
|
|
132
|
+
` : "") + ` \u2192 stop it first: screentest stop
|
|
126
133
|
\u2192 then re-run: screentest serve
|
|
127
134
|
`
|
|
128
135
|
);
|
|
129
136
|
}
|
|
130
137
|
}
|
|
131
|
-
function startContainer() {
|
|
132
|
-
spawnSync("docker", ["rm",
|
|
138
|
+
function startContainer(staleId) {
|
|
139
|
+
if (staleId) spawnSync("docker", ["rm", staleId], { stdio: "pipe" });
|
|
140
|
+
const idle = process.env[IDLE_ENV];
|
|
133
141
|
const r = spawnSync(
|
|
134
142
|
"docker",
|
|
135
|
-
[
|
|
143
|
+
[
|
|
144
|
+
"run",
|
|
145
|
+
"-d",
|
|
146
|
+
"--rm",
|
|
147
|
+
"--name",
|
|
148
|
+
CONTAINER_NAME,
|
|
149
|
+
"--network=host",
|
|
150
|
+
...idle ? ["-e", `${IDLE_ENV}=${idle}`] : [],
|
|
151
|
+
FULL_IMAGE
|
|
152
|
+
],
|
|
136
153
|
{ stdio: "pipe", encoding: "utf8" }
|
|
137
154
|
);
|
|
138
155
|
return { ok: !r.error && r.status === 0, stderr: r.stderr?.trim() ?? String(r.error) };
|
|
139
156
|
}
|
|
140
157
|
async function ensureDaemon() {
|
|
141
|
-
|
|
158
|
+
let deadline = Date.now() + START_TIMEOUT_MS;
|
|
142
159
|
let started = false;
|
|
143
160
|
let lastError = "";
|
|
161
|
+
let deafId = "";
|
|
162
|
+
let deafSince = 0;
|
|
144
163
|
for (; ; ) {
|
|
145
164
|
const s = daemonState();
|
|
146
165
|
assertUsable(s);
|
|
147
166
|
if (s.state === "running") {
|
|
148
|
-
if (await
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
167
|
+
if (await probeServer() && sameRunningContainer(s.id)) return { started };
|
|
168
|
+
if (deafId !== s.id) {
|
|
169
|
+
deafId = s.id;
|
|
170
|
+
deafSince = Date.now();
|
|
171
|
+
}
|
|
172
|
+
const now = Date.now();
|
|
173
|
+
if (now - deafSince > READY_TIMEOUT_MS || now > deadline + READY_TIMEOUT_MS) {
|
|
174
|
+
spawnSync("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
|
|
175
|
+
throw new Error(
|
|
176
|
+
`screentest-firefox daemon container is up but never answered on port ${PORT}.
|
|
152
177
|
`
|
|
153
|
-
|
|
178
|
+
);
|
|
179
|
+
}
|
|
180
|
+
await sleep(150);
|
|
181
|
+
continue;
|
|
154
182
|
}
|
|
155
183
|
if (Date.now() > deadline) {
|
|
156
184
|
throw new Error(
|
|
@@ -159,14 +187,15 @@ async function ensureDaemon() {
|
|
|
159
187
|
`
|
|
160
188
|
);
|
|
161
189
|
}
|
|
162
|
-
if (s.state === "missing-image"
|
|
163
|
-
throw new Error(`could not build ${FULL_IMAGE}
|
|
190
|
+
if (s.state === "missing-image") {
|
|
191
|
+
if (!await buildImage()) throw new Error(`could not build ${FULL_IMAGE}
|
|
164
192
|
`);
|
|
193
|
+
deadline = Date.now() + START_TIMEOUT_MS;
|
|
165
194
|
}
|
|
166
195
|
if (s.state === "stopped" || s.state === "missing-image") {
|
|
167
196
|
if (!started) process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
|
|
168
197
|
`);
|
|
169
|
-
const r = startContainer();
|
|
198
|
+
const r = startContainer(s.staleId);
|
|
170
199
|
if (r.ok) started = true;
|
|
171
200
|
else lastError = r.stderr;
|
|
172
201
|
}
|
|
@@ -15053,16 +15082,18 @@ var PROBE_HTML = `<!doctype html><html><body style="margin:0;background:#fff">
|
|
|
15053
15082
|
<p style="font:17px serif;margin:4px 0;transform:rotate(-3.7deg)">rotated glyphs</p>
|
|
15054
15083
|
<div style="height:24px;border-radius:11px;border:1.5px solid #357;background:linear-gradient(97deg,#f06,#0af)"></div>
|
|
15055
15084
|
</div></body></html>`;
|
|
15056
|
-
async function
|
|
15057
|
-
|
|
15085
|
+
async function connectRenderer(wsEndpoint) {
|
|
15086
|
+
return firefox.connect(wsEndpoint, { timeout: 3e4 }).catch((err) => {
|
|
15058
15087
|
const msg = err instanceof Error ? err.message.split("\n")[0] : String(err);
|
|
15059
15088
|
throw new Error(`[screentest] cannot reach the renderer at ${wsEndpoint}: ${msg}`);
|
|
15060
15089
|
});
|
|
15090
|
+
}
|
|
15091
|
+
async function probeRenderer(browser, source) {
|
|
15092
|
+
const ctx = await browser.newContext({
|
|
15093
|
+
...CONTEXT_DEFAULTS,
|
|
15094
|
+
viewport: { width: 400, height: 240 }
|
|
15095
|
+
});
|
|
15061
15096
|
try {
|
|
15062
|
-
const ctx = await browser.newContext({
|
|
15063
|
-
...CONTEXT_DEFAULTS,
|
|
15064
|
-
viewport: { width: 400, height: 240 }
|
|
15065
|
-
});
|
|
15066
15097
|
const page = await ctx.newPage();
|
|
15067
15098
|
await page.setContent(PROBE_HTML);
|
|
15068
15099
|
await waitForVisualStable(page);
|
|
@@ -15072,7 +15103,7 @@ async function probeRenderer(wsEndpoint, source) {
|
|
|
15072
15103
|
label: `${source}, firefox-${browser.version()}`
|
|
15073
15104
|
};
|
|
15074
15105
|
} finally {
|
|
15075
|
-
await
|
|
15106
|
+
await ctx.close().catch(() => {
|
|
15076
15107
|
});
|
|
15077
15108
|
}
|
|
15078
15109
|
}
|
|
@@ -15086,12 +15117,7 @@ async function exists(p) {
|
|
|
15086
15117
|
return false;
|
|
15087
15118
|
}
|
|
15088
15119
|
}
|
|
15089
|
-
async function
|
|
15090
|
-
const externalWs = process.env.SCREENTEST_FIREFOX_WS;
|
|
15091
|
-
if (externalWs) {
|
|
15092
|
-
console.log(`[screentest] using firefox WS from env: ${externalWs}`);
|
|
15093
|
-
return { ws: externalWs, source: "SCREENTEST_FIREFOX_WS" };
|
|
15094
|
-
}
|
|
15120
|
+
async function ensureDaemonOrExplain() {
|
|
15095
15121
|
try {
|
|
15096
15122
|
await ensureDaemon();
|
|
15097
15123
|
} catch (err) {
|
|
@@ -15099,8 +15125,25 @@ async function resolveWsEndpoint() {
|
|
|
15099
15125
|
throw new Error(`[screentest] cannot take screenshots:
|
|
15100
15126
|
${msg}`);
|
|
15101
15127
|
}
|
|
15128
|
+
}
|
|
15129
|
+
async function resolveWsEndpoint() {
|
|
15130
|
+
const externalWs = process.env.SCREENTEST_FIREFOX_WS;
|
|
15131
|
+
if (externalWs) {
|
|
15132
|
+
console.log(`[screentest] using firefox WS from env: ${externalWs}`);
|
|
15133
|
+
return { ws: externalWs, source: "SCREENTEST_FIREFOX_WS", daemon: false };
|
|
15134
|
+
}
|
|
15135
|
+
await ensureDaemonOrExplain();
|
|
15102
15136
|
console.log(`[screentest] using firefox daemon at ${WS_ENDPOINT}`);
|
|
15103
|
-
return { ws: WS_ENDPOINT, source: FULL_IMAGE };
|
|
15137
|
+
return { ws: WS_ENDPOINT, source: FULL_IMAGE, daemon: true };
|
|
15138
|
+
}
|
|
15139
|
+
async function connectLease(ws, daemon) {
|
|
15140
|
+
try {
|
|
15141
|
+
return await connectRenderer(ws);
|
|
15142
|
+
} catch (err) {
|
|
15143
|
+
if (!daemon) throw err;
|
|
15144
|
+
await ensureDaemonOrExplain();
|
|
15145
|
+
return connectRenderer(ws);
|
|
15146
|
+
}
|
|
15104
15147
|
}
|
|
15105
15148
|
function detectVitestFilter() {
|
|
15106
15149
|
if (process.env.SCREENTEST_FORCE_DELETION_DETECTION) {
|
|
@@ -15146,17 +15189,27 @@ function spawnUI(docFile) {
|
|
|
15146
15189
|
}
|
|
15147
15190
|
async function setup(project) {
|
|
15148
15191
|
const paths = resolveRunnerPaths();
|
|
15149
|
-
const { ws, source } = await resolveWsEndpoint();
|
|
15150
|
-
const
|
|
15151
|
-
|
|
15152
|
-
|
|
15153
|
-
|
|
15154
|
-
await
|
|
15155
|
-
|
|
15156
|
-
|
|
15157
|
-
|
|
15158
|
-
|
|
15192
|
+
const { ws, source, daemon } = await resolveWsEndpoint();
|
|
15193
|
+
const lease = await connectLease(ws, daemon);
|
|
15194
|
+
const release = () => lease.close().catch(() => {
|
|
15195
|
+
});
|
|
15196
|
+
try {
|
|
15197
|
+
const renderer = await probeRenderer(lease, source);
|
|
15198
|
+
if (!daemon) await release();
|
|
15199
|
+
project.provide("wsEndpoint", ws);
|
|
15200
|
+
await fs2.mkdir(paths.cacheDir, { recursive: true });
|
|
15201
|
+
if (!await exists(paths.snapshotFile)) {
|
|
15202
|
+
await fs2.mkdir(dirname2(paths.snapshotFile), { recursive: true });
|
|
15203
|
+
await fs2.writeFile(paths.snapshotFile, '{\n "groups": []\n}\n');
|
|
15204
|
+
}
|
|
15205
|
+
await fs2.rm(paths.actualDir, { recursive: true, force: true });
|
|
15206
|
+
await fs2.writeFile(paths.runFile, JSON.stringify({ renderer }, null, 2) + "\n");
|
|
15207
|
+
} catch (err) {
|
|
15208
|
+
await release();
|
|
15209
|
+
throw err;
|
|
15210
|
+
}
|
|
15159
15211
|
return async () => {
|
|
15212
|
+
await release();
|
|
15160
15213
|
const filter = detectVitestFilter();
|
|
15161
15214
|
if (filter.filtered) {
|
|
15162
15215
|
process.stderr.write(
|
package/dist/index.js
CHANGED
|
@@ -15554,13 +15554,16 @@ import { request } from "http";
|
|
|
15554
15554
|
import { dirname as dirname6, resolve as resolve8 } from "path";
|
|
15555
15555
|
import { fileURLToPath as fileURLToPath4 } from "url";
|
|
15556
15556
|
var IMAGE_NAME = "cevek/screentest-firefox";
|
|
15557
|
-
var IMAGE_TAG = "pw-1.60.0";
|
|
15557
|
+
var IMAGE_TAG = "pw-1.60.0-r2";
|
|
15558
|
+
var PRE_IDLE_STOP_IMAGE = `${IMAGE_NAME}:pw-1.60.0`;
|
|
15558
15559
|
var FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_TAG}`;
|
|
15559
15560
|
var CONTAINER_NAME = "screentest-firefox";
|
|
15560
15561
|
var PORT = 5180;
|
|
15561
15562
|
var WS_PATH = "screentest-firefox";
|
|
15562
15563
|
var WS_ENDPOINT = `ws://localhost:${PORT}/${WS_PATH}`;
|
|
15563
15564
|
var START_TIMEOUT_MS = 3e4;
|
|
15565
|
+
var READY_TIMEOUT_MS = 15e3;
|
|
15566
|
+
var IDLE_ENV = "SCREENTEST_DAEMON_IDLE_SECONDS";
|
|
15564
15567
|
function run2(cmd, argv) {
|
|
15565
15568
|
return new Promise((resolveExit) => {
|
|
15566
15569
|
const p = spawn2(cmd, argv, { stdio: "inherit" });
|
|
@@ -15571,20 +15574,32 @@ function run2(cmd, argv) {
|
|
|
15571
15574
|
function daemonState() {
|
|
15572
15575
|
const ps = spawnSync2(
|
|
15573
15576
|
"docker",
|
|
15574
|
-
["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}}"],
|
|
15577
|
+
["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}} {{.ID}}"],
|
|
15575
15578
|
{ stdio: "pipe", encoding: "utf8" }
|
|
15576
15579
|
);
|
|
15577
15580
|
if (ps.error) return { state: "no-docker", reason: ps.error.message };
|
|
15578
15581
|
if (ps.status !== 0) return { state: "no-docker", reason: ps.stderr.trim() };
|
|
15579
|
-
const [status = "", image = ""] = ps.stdout.trim().split(" ");
|
|
15580
|
-
if (status === "running") return { state: "running", image: image.trim() };
|
|
15581
|
-
if (status === "paused") return { state: "paused" };
|
|
15582
|
+
const [status = "", image = "", id = ""] = ps.stdout.trim().split(" ");
|
|
15583
|
+
if (status === "running") return { state: "running", image: image.trim(), id: id.trim() };
|
|
15584
|
+
if (status === "paused") return { state: "paused", id: id.trim() };
|
|
15582
15585
|
if (status === "created" || status === "restarting" || status === "removing") {
|
|
15583
15586
|
return { state: "transitional", status };
|
|
15584
15587
|
}
|
|
15588
|
+
const staleId = id.trim();
|
|
15585
15589
|
const img = spawnSync2("docker", ["image", "inspect", FULL_IMAGE], { stdio: "pipe" });
|
|
15586
|
-
if (img.status !== 0) return { state: "missing-image" };
|
|
15587
|
-
return { state: "stopped" };
|
|
15590
|
+
if (img.status !== 0) return { state: "missing-image", staleId };
|
|
15591
|
+
return { state: "stopped", staleId };
|
|
15592
|
+
}
|
|
15593
|
+
function sameRunningContainer(id) {
|
|
15594
|
+
const s = daemonState();
|
|
15595
|
+
return s.state === "running" && s.id === id;
|
|
15596
|
+
}
|
|
15597
|
+
function containerExists(id) {
|
|
15598
|
+
const r = spawnSync2("docker", ["ps", "-aq", "--no-trunc", "-f", `id=${id}`], {
|
|
15599
|
+
stdio: "pipe",
|
|
15600
|
+
encoding: "utf8"
|
|
15601
|
+
});
|
|
15602
|
+
return r.status !== 0 || r.stdout.trim() !== "";
|
|
15588
15603
|
}
|
|
15589
15604
|
function resolveTemplatesDir() {
|
|
15590
15605
|
const here = dirname6(fileURLToPath4(import.meta.url));
|
|
@@ -15619,7 +15634,13 @@ async function buildImage() {
|
|
|
15619
15634
|
}
|
|
15620
15635
|
function probeServer() {
|
|
15621
15636
|
return new Promise((resolveProbe) => {
|
|
15622
|
-
const req = request({
|
|
15637
|
+
const req = request({
|
|
15638
|
+
host: "127.0.0.1",
|
|
15639
|
+
port: PORT,
|
|
15640
|
+
path: `/${WS_PATH}`,
|
|
15641
|
+
timeout: 1e3,
|
|
15642
|
+
agent: false
|
|
15643
|
+
});
|
|
15623
15644
|
req.once("response", (res) => {
|
|
15624
15645
|
res.resume();
|
|
15625
15646
|
resolveProbe(true);
|
|
@@ -15629,14 +15650,6 @@ function probeServer() {
|
|
|
15629
15650
|
req.end();
|
|
15630
15651
|
});
|
|
15631
15652
|
}
|
|
15632
|
-
async function waitForReady(timeoutMs = 1e4) {
|
|
15633
|
-
const start = Date.now();
|
|
15634
|
-
while (Date.now() - start < timeoutMs) {
|
|
15635
|
-
if (await probeServer()) return true;
|
|
15636
|
-
await sleep(150);
|
|
15637
|
-
}
|
|
15638
|
-
return false;
|
|
15639
|
-
}
|
|
15640
15653
|
function sleep(ms) {
|
|
15641
15654
|
return new Promise((r) => setTimeout(r, ms));
|
|
15642
15655
|
}
|
|
@@ -15659,35 +15672,57 @@ container (${FULL_IMAGE}). Start Docker, then re-run.
|
|
|
15659
15672
|
`screentest-firefox daemon is running, but on a different image:
|
|
15660
15673
|
running: ${s.image}
|
|
15661
15674
|
this @cevek/screentest wants: ${FULL_IMAGE}
|
|
15662
|
-
|
|
15675
|
+
` + (s.image === PRE_IDLE_STOP_IMAGE ? ` (daemons from @cevek/screentest < 0.6 never stop on their own)
|
|
15676
|
+
` : "") + ` \u2192 stop it first: screentest stop
|
|
15663
15677
|
\u2192 then re-run: screentest serve
|
|
15664
15678
|
`
|
|
15665
15679
|
);
|
|
15666
15680
|
}
|
|
15667
15681
|
}
|
|
15668
|
-
function startContainer() {
|
|
15669
|
-
spawnSync2("docker", ["rm",
|
|
15682
|
+
function startContainer(staleId) {
|
|
15683
|
+
if (staleId) spawnSync2("docker", ["rm", staleId], { stdio: "pipe" });
|
|
15684
|
+
const idle = process.env[IDLE_ENV];
|
|
15670
15685
|
const r = spawnSync2(
|
|
15671
15686
|
"docker",
|
|
15672
|
-
[
|
|
15687
|
+
[
|
|
15688
|
+
"run",
|
|
15689
|
+
"-d",
|
|
15690
|
+
"--rm",
|
|
15691
|
+
"--name",
|
|
15692
|
+
CONTAINER_NAME,
|
|
15693
|
+
"--network=host",
|
|
15694
|
+
...idle ? ["-e", `${IDLE_ENV}=${idle}`] : [],
|
|
15695
|
+
FULL_IMAGE
|
|
15696
|
+
],
|
|
15673
15697
|
{ stdio: "pipe", encoding: "utf8" }
|
|
15674
15698
|
);
|
|
15675
15699
|
return { ok: !r.error && r.status === 0, stderr: r.stderr?.trim() ?? String(r.error) };
|
|
15676
15700
|
}
|
|
15677
15701
|
async function ensureDaemon() {
|
|
15678
|
-
|
|
15702
|
+
let deadline = Date.now() + START_TIMEOUT_MS;
|
|
15679
15703
|
let started = false;
|
|
15680
15704
|
let lastError = "";
|
|
15705
|
+
let deafId = "";
|
|
15706
|
+
let deafSince = 0;
|
|
15681
15707
|
for (; ; ) {
|
|
15682
15708
|
const s = daemonState();
|
|
15683
15709
|
assertUsable(s);
|
|
15684
15710
|
if (s.state === "running") {
|
|
15685
|
-
if (await
|
|
15686
|
-
|
|
15687
|
-
|
|
15688
|
-
|
|
15711
|
+
if (await probeServer() && sameRunningContainer(s.id)) return { started };
|
|
15712
|
+
if (deafId !== s.id) {
|
|
15713
|
+
deafId = s.id;
|
|
15714
|
+
deafSince = Date.now();
|
|
15715
|
+
}
|
|
15716
|
+
const now = Date.now();
|
|
15717
|
+
if (now - deafSince > READY_TIMEOUT_MS || now > deadline + READY_TIMEOUT_MS) {
|
|
15718
|
+
spawnSync2("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
|
|
15719
|
+
throw new Error(
|
|
15720
|
+
`screentest-firefox daemon container is up but never answered on port ${PORT}.
|
|
15689
15721
|
`
|
|
15690
|
-
|
|
15722
|
+
);
|
|
15723
|
+
}
|
|
15724
|
+
await sleep(150);
|
|
15725
|
+
continue;
|
|
15691
15726
|
}
|
|
15692
15727
|
if (Date.now() > deadline) {
|
|
15693
15728
|
throw new Error(
|
|
@@ -15696,14 +15731,15 @@ async function ensureDaemon() {
|
|
|
15696
15731
|
`
|
|
15697
15732
|
);
|
|
15698
15733
|
}
|
|
15699
|
-
if (s.state === "missing-image"
|
|
15700
|
-
throw new Error(`could not build ${FULL_IMAGE}
|
|
15734
|
+
if (s.state === "missing-image") {
|
|
15735
|
+
if (!await buildImage()) throw new Error(`could not build ${FULL_IMAGE}
|
|
15701
15736
|
`);
|
|
15737
|
+
deadline = Date.now() + START_TIMEOUT_MS;
|
|
15702
15738
|
}
|
|
15703
15739
|
if (s.state === "stopped" || s.state === "missing-image") {
|
|
15704
15740
|
if (!started) process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
|
|
15705
15741
|
`);
|
|
15706
|
-
const r = startContainer();
|
|
15742
|
+
const r = startContainer(s.staleId);
|
|
15707
15743
|
if (r.ok) started = true;
|
|
15708
15744
|
else lastError = r.stderr;
|
|
15709
15745
|
}
|
|
@@ -15729,9 +15765,10 @@ async function stopDaemon() {
|
|
|
15729
15765
|
process.stdout.write("screentest-firefox daemon is not running\n");
|
|
15730
15766
|
return 0;
|
|
15731
15767
|
}
|
|
15732
|
-
const code = await run2("docker", ["stop",
|
|
15733
|
-
|
|
15734
|
-
|
|
15768
|
+
const code = await run2("docker", ["stop", s.id]);
|
|
15769
|
+
const gone = code === 0 || !containerExists(s.id);
|
|
15770
|
+
if (gone) process.stdout.write("screentest-firefox daemon stopped\n");
|
|
15771
|
+
return gone ? 0 : code;
|
|
15735
15772
|
}
|
|
15736
15773
|
async function printStatus() {
|
|
15737
15774
|
const s = daemonState();
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
import net from 'node:net';
|
|
2
|
+
|
|
3
|
+
export const DEFAULT_IDLE_SECONDS = 180;
|
|
4
|
+
// A cold start must survive until the host's readiness probe and lease
|
|
5
|
+
// connect land (ensureDaemon polls every 150–300 ms; Firefox may be slow).
|
|
6
|
+
export const MIN_IDLE_SECONDS = 10;
|
|
7
|
+
// setTimeout overflows above 2^31-1 ms and fires after 1 ms instead.
|
|
8
|
+
const MAX_TIMER_MS = 2 ** 31 - 1;
|
|
9
|
+
|
|
10
|
+
/**
|
|
11
|
+
* `SCREENTEST_DAEMON_IDLE_SECONDS`: a non-negative number, `0` = never stop,
|
|
12
|
+
* raised to MIN_IDLE_SECONDS. Anything else falls back to the default rather
|
|
13
|
+
* than disabling the stop.
|
|
14
|
+
*
|
|
15
|
+
* @param {string | undefined} raw
|
|
16
|
+
* @returns {number}
|
|
17
|
+
*/
|
|
18
|
+
export function parseIdleSeconds(raw) {
|
|
19
|
+
const s = raw?.trim() ?? '';
|
|
20
|
+
if (!/^\d+(\.\d+)?$/.test(s)) return DEFAULT_IDLE_SECONDS;
|
|
21
|
+
const n = Number(s);
|
|
22
|
+
return n === 0 ? 0 : Math.max(n, MIN_IDLE_SECONDS);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/**
|
|
26
|
+
* TCP proxy in front of the Playwright browser-server that counts open client
|
|
27
|
+
* connections; Playwright's BrowserServer exposes no such count. Calls
|
|
28
|
+
* `onIdle` once after `idleMs` with no connection open (counted from start
|
|
29
|
+
* and from every drop to zero), after it has already stopped accepting.
|
|
30
|
+
* `idleMs <= 0` never fires; `close()` stops it for good.
|
|
31
|
+
*
|
|
32
|
+
* @param {{ host: string; port: number; upstreamPort: number; idleMs: number; onIdle: () => void }} opts
|
|
33
|
+
* @returns {Promise<{ port: number; close: () => void }>}
|
|
34
|
+
*/
|
|
35
|
+
export function startIdleProxy({ host, port, upstreamPort, idleMs, onIdle }) {
|
|
36
|
+
let open = 0;
|
|
37
|
+
let stopped = false;
|
|
38
|
+
let timer;
|
|
39
|
+
const stop = () => {
|
|
40
|
+
stopped = true;
|
|
41
|
+
clearTimeout(timer);
|
|
42
|
+
proxy.close();
|
|
43
|
+
};
|
|
44
|
+
const wait = (until) => {
|
|
45
|
+
timer = setTimeout(
|
|
46
|
+
() => {
|
|
47
|
+
if (Date.now() < until) return wait(until);
|
|
48
|
+
stop();
|
|
49
|
+
onIdle();
|
|
50
|
+
},
|
|
51
|
+
Math.min(until - Date.now(), MAX_TIMER_MS),
|
|
52
|
+
);
|
|
53
|
+
};
|
|
54
|
+
const arm = () => {
|
|
55
|
+
if (stopped || idleMs <= 0) return;
|
|
56
|
+
wait(Date.now() + idleMs);
|
|
57
|
+
};
|
|
58
|
+
|
|
59
|
+
// Half-open on both legs: a client's FIN must not cut off the reply still
|
|
60
|
+
// coming back. `pipe` forwards each FIN; 'close' fires once both are done.
|
|
61
|
+
const proxy = net.createServer({ allowHalfOpen: true }, (client) => {
|
|
62
|
+
clearTimeout(timer);
|
|
63
|
+
open += 1;
|
|
64
|
+
const upstream = net.connect({ port: upstreamPort, host: '127.0.0.1', allowHalfOpen: true });
|
|
65
|
+
client.pipe(upstream);
|
|
66
|
+
upstream.pipe(client);
|
|
67
|
+
client.on('error', () => upstream.destroy());
|
|
68
|
+
upstream.on('error', () => client.destroy());
|
|
69
|
+
client.on('close', () => {
|
|
70
|
+
upstream.destroy();
|
|
71
|
+
open -= 1;
|
|
72
|
+
if (open === 0) arm();
|
|
73
|
+
});
|
|
74
|
+
upstream.on('close', () => client.destroy());
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
return new Promise((resolveStart, rejectStart) => {
|
|
78
|
+
proxy.once('error', rejectStart);
|
|
79
|
+
proxy.listen(port, host, () => {
|
|
80
|
+
proxy.off('error', rejectStart);
|
|
81
|
+
arm();
|
|
82
|
+
resolveStart({
|
|
83
|
+
port: /** @type {net.AddressInfo} */ (proxy.address()).port,
|
|
84
|
+
close: stop,
|
|
85
|
+
});
|
|
86
|
+
});
|
|
87
|
+
});
|
|
88
|
+
}
|
|
@@ -1,22 +1,47 @@
|
|
|
1
1
|
// Long-lived headless Firefox browser-server. Tests on the host connect via
|
|
2
2
|
// WS, see playwright.dev/docs/api/class-browsertype#browser-type-launch-server
|
|
3
3
|
import { firefox } from 'playwright';
|
|
4
|
+
import { parseIdleSeconds, startIdleProxy } from './idle-proxy.mjs';
|
|
4
5
|
|
|
5
6
|
const port = Number.parseInt(process.env.SCREENTEST_PORT ?? '5180', 10);
|
|
6
7
|
const wsPath = process.env.SCREENTEST_WS_PATH ?? 'screentest-firefox';
|
|
8
|
+
const idleSeconds = parseIdleSeconds(process.env.SCREENTEST_DAEMON_IDLE_SECONDS);
|
|
9
|
+
// A Firefox that hangs on close must not leave a running container with no
|
|
10
|
+
// listener: ensureDaemon gives such a container READY_TIMEOUT_MS (daemon.ts)
|
|
11
|
+
// before failing instead of starting anew.
|
|
12
|
+
const FORCE_EXIT_MS = 5_000;
|
|
7
13
|
|
|
8
|
-
|
|
9
|
-
|
|
14
|
+
// Random loopback port: clients reach Firefox only through the counting proxy.
|
|
15
|
+
const server = await firefox.launchServer({ port: 0, host: '127.0.0.1', wsPath });
|
|
16
|
+
const upstreamPort = Number(new URL(server.wsEndpoint()).port);
|
|
17
|
+
|
|
18
|
+
let closing = false;
|
|
19
|
+
const shutdown = async (reason, code = 0) => {
|
|
20
|
+
if (closing) return;
|
|
21
|
+
closing = true;
|
|
22
|
+
console.log(`[screentest] ${reason}, closing browser-server`);
|
|
23
|
+
proxy.close();
|
|
24
|
+
setTimeout(() => process.exit(code), FORCE_EXIT_MS).unref();
|
|
25
|
+
await server.close().catch(() => {});
|
|
26
|
+
process.exit(code);
|
|
27
|
+
};
|
|
28
|
+
|
|
29
|
+
const proxy = await startIdleProxy({
|
|
10
30
|
host: '0.0.0.0',
|
|
11
|
-
|
|
31
|
+
port,
|
|
32
|
+
upstreamPort,
|
|
33
|
+
idleMs: idleSeconds * 1000,
|
|
34
|
+
onIdle: () => void shutdown(`no clients for ${idleSeconds}s`),
|
|
12
35
|
});
|
|
13
36
|
|
|
14
|
-
|
|
37
|
+
// Firefox died on its own: exit so `--rm` frees the name for a fresh daemon
|
|
38
|
+
// instead of a proxy that forwards to nothing.
|
|
39
|
+
server.on('close', () => void shutdown('browser-server closed unexpectedly', 1));
|
|
15
40
|
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
process.on('SIGTERM', () => void shutdown('SIGTERM'));
|
|
22
|
-
process.on('SIGINT', () => void shutdown('SIGINT'));
|
|
41
|
+
console.log(
|
|
42
|
+
`[screentest] firefox browser-server ready on port ${port}` +
|
|
43
|
+
(idleSeconds > 0 ? `, stops after ${idleSeconds}s without clients` : ''),
|
|
44
|
+
);
|
|
45
|
+
|
|
46
|
+
process.on('SIGTERM', () => void shutdown('received SIGTERM'));
|
|
47
|
+
process.on('SIGINT', () => void shutdown('received SIGINT'));
|
package/package.json
CHANGED
|
@@ -3,7 +3,7 @@
|
|
|
3
3
|
"publishConfig": {
|
|
4
4
|
"access": "public"
|
|
5
5
|
},
|
|
6
|
-
"version": "0.
|
|
6
|
+
"version": "0.6.0",
|
|
7
7
|
"description": "Local desktop tool for visual screenshot-test review — CLI, runner helpers, and review UI shipped as a single package.",
|
|
8
8
|
"license": "MIT",
|
|
9
9
|
"type": "module",
|
|
@@ -28,6 +28,7 @@
|
|
|
28
28
|
"build": "tsup && node scripts/postbuild.mjs",
|
|
29
29
|
"start": "node dist/index.js",
|
|
30
30
|
"typecheck": "tsc --noEmit",
|
|
31
|
+
"test": "vitest run",
|
|
31
32
|
"prepublishOnly": "pnpm -w typecheck && pnpm -w build"
|
|
32
33
|
},
|
|
33
34
|
"dependencies": {
|