@cevek/screentest 0.4.0 → 0.5.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 +11 -9
- package/dist/global-setup.js +14945 -69
- package/dist/index.js +207 -69
- package/dist/runner.js +12 -7
- package/dist/web/assets/index-CQ8ij0HR.js +72 -0
- package/dist/web/assets/index-DWf2oQZg.css +1 -0
- package/dist/web/index.html +2 -2
- package/package.json +1 -1
- package/dist/web/assets/index-BWHB66Bb.js +0 -72
- package/dist/web/assets/index-Bi-jx470.css +0 -1
package/dist/index.js
CHANGED
|
@@ -14560,9 +14560,24 @@ var projectInfoSchema = external_exports.object({
|
|
|
14560
14560
|
/** Current git branch, or `null` if not a git repo (or `git` not on PATH). */
|
|
14561
14561
|
branch: external_exports.string().nullable()
|
|
14562
14562
|
});
|
|
14563
|
+
var rendererSchema = external_exports.object({
|
|
14564
|
+
fingerprint: external_exports.string().min(1),
|
|
14565
|
+
label: external_exports.string()
|
|
14566
|
+
});
|
|
14563
14567
|
var docSchema = external_exports.object({
|
|
14564
14568
|
/** Optional for backward compatibility with pre-0.3 doc.json files. */
|
|
14565
14569
|
project: projectInfoSchema.optional(),
|
|
14570
|
+
/**
|
|
14571
|
+
* `current` shot this run's actuals; `baseline` is what snapshot.json
|
|
14572
|
+
* records for its hashes (null when it records none). `mismatch`: the
|
|
14573
|
+
* renderers differ AND the diffs look like it (see generateDoc). Optional
|
|
14574
|
+
* for pre-0.5 doc.json files.
|
|
14575
|
+
*/
|
|
14576
|
+
renderer: external_exports.object({
|
|
14577
|
+
current: rendererSchema,
|
|
14578
|
+
baseline: rendererSchema.nullable(),
|
|
14579
|
+
mismatch: external_exports.boolean()
|
|
14580
|
+
}).optional(),
|
|
14566
14581
|
groups: external_exports.array(groupItemSchema)
|
|
14567
14582
|
});
|
|
14568
14583
|
var snapshotTestSchema = external_exports.object({
|
|
@@ -14576,6 +14591,7 @@ var snapshotGroupSchema = external_exports.lazy(
|
|
|
14576
14591
|
})
|
|
14577
14592
|
);
|
|
14578
14593
|
var snapshotDocSchema = external_exports.object({
|
|
14594
|
+
renderer: rendererSchema.optional(),
|
|
14579
14595
|
groups: external_exports.array(snapshotGroupSchema)
|
|
14580
14596
|
});
|
|
14581
14597
|
var apiDocResponseSchema = external_exports.object({
|
|
@@ -14859,6 +14875,9 @@ async function withFileLock(absPath, fn) {
|
|
|
14859
14875
|
function isSnapshotGroup(x) {
|
|
14860
14876
|
return Array.isArray(x.items);
|
|
14861
14877
|
}
|
|
14878
|
+
function hasAnyHash(items) {
|
|
14879
|
+
return items.some((n) => isSnapshotGroup(n) ? hasAnyHash(n.items) : n.hash !== null);
|
|
14880
|
+
}
|
|
14862
14881
|
function upsertHash(doc, path, hash2) {
|
|
14863
14882
|
if (path.length === 0) throw new Error("Empty path for upsertHash");
|
|
14864
14883
|
const testName = path[path.length - 1];
|
|
@@ -14950,7 +14969,9 @@ async function patchSnapshot(args) {
|
|
|
14950
14969
|
throw err;
|
|
14951
14970
|
}
|
|
14952
14971
|
}
|
|
14972
|
+
const fresh = !doc.renderer && !hasAnyHash(doc.groups);
|
|
14953
14973
|
upsertHash(doc, args.path, args.hash);
|
|
14974
|
+
if (args.renderer && fresh) doc = { renderer: args.renderer, groups: doc.groups };
|
|
14954
14975
|
await atomicWriteJson(abs, doc);
|
|
14955
14976
|
});
|
|
14956
14977
|
}
|
|
@@ -14990,7 +15011,8 @@ function acceptRoute(state) {
|
|
|
14990
15011
|
docDir: state.docDir,
|
|
14991
15012
|
patchSnapshotJsonFile: entry.item.patchSnapshotJsonFile,
|
|
14992
15013
|
path: [...entry.parents, entry.name],
|
|
14993
|
-
hash: hash2
|
|
15014
|
+
hash: hash2,
|
|
15015
|
+
renderer: state.doc.renderer?.current
|
|
14994
15016
|
});
|
|
14995
15017
|
res.json({
|
|
14996
15018
|
hash: hash2,
|
|
@@ -15256,6 +15278,27 @@ function detectBranch(projectRoot) {
|
|
|
15256
15278
|
const branch = r.stdout.trim();
|
|
15257
15279
|
return branch || null;
|
|
15258
15280
|
}
|
|
15281
|
+
async function readRunRenderer(runFile) {
|
|
15282
|
+
try {
|
|
15283
|
+
const run3 = JSON.parse(await fs4.readFile(runFile, "utf8"));
|
|
15284
|
+
const parsed = rendererSchema.safeParse(run3.renderer);
|
|
15285
|
+
return parsed.success ? parsed.data : null;
|
|
15286
|
+
} catch {
|
|
15287
|
+
return null;
|
|
15288
|
+
}
|
|
15289
|
+
}
|
|
15290
|
+
function baselineRenderer(snap) {
|
|
15291
|
+
const parsed = rendererSchema.safeParse(snap.renderer);
|
|
15292
|
+
return parsed.success ? parsed.data : null;
|
|
15293
|
+
}
|
|
15294
|
+
async function writeSnapshotRenderer(snapshotFile, renderer) {
|
|
15295
|
+
const raw = JSON.parse(await fs4.readFile(snapshotFile, "utf8"));
|
|
15296
|
+
const { renderer: _old, ...rest } = raw;
|
|
15297
|
+
await fs4.writeFile(snapshotFile, JSON.stringify({ renderer, ...rest }, null, 2) + "\n");
|
|
15298
|
+
}
|
|
15299
|
+
function describeRenderer(r) {
|
|
15300
|
+
return `${r.label} [${r.fingerprint}]`;
|
|
15301
|
+
}
|
|
15259
15302
|
function isGroup(node) {
|
|
15260
15303
|
return Array.isArray(node.items);
|
|
15261
15304
|
}
|
|
@@ -15319,8 +15362,9 @@ function countLeaves(doc) {
|
|
|
15319
15362
|
for (const g of doc.groups) walk(g.items);
|
|
15320
15363
|
return n;
|
|
15321
15364
|
}
|
|
15322
|
-
async function generateDoc(
|
|
15323
|
-
const
|
|
15365
|
+
async function generateDoc(paths, opts = {}) {
|
|
15366
|
+
const { projectRoot, snapshotFile, actualDir, docFile, cacheDir } = paths;
|
|
15367
|
+
const fullRun = opts.fullRun ?? true;
|
|
15324
15368
|
const snap = await readSnapshot(snapshotFile);
|
|
15325
15369
|
const expectedByPath = indexSnapshot(snap);
|
|
15326
15370
|
const actuals = await walkActual(actualDir);
|
|
@@ -15358,7 +15402,7 @@ async function generateDoc(projectRoot, snapshotFile, actualDir, docFile, cacheD
|
|
|
15358
15402
|
});
|
|
15359
15403
|
summary.change++;
|
|
15360
15404
|
}
|
|
15361
|
-
if (
|
|
15405
|
+
if (fullRun) {
|
|
15362
15406
|
for (const [key, hash2] of expectedByPath) {
|
|
15363
15407
|
if (seen.has(key) || !hash2) continue;
|
|
15364
15408
|
insertLeaf(doc, key.split("/"), {
|
|
@@ -15369,13 +15413,47 @@ async function generateDoc(projectRoot, snapshotFile, actualDir, docFile, cacheD
|
|
|
15369
15413
|
summary.deleted++;
|
|
15370
15414
|
}
|
|
15371
15415
|
}
|
|
15416
|
+
const current = await readRunRenderer(paths.runFile);
|
|
15417
|
+
let baseline = baselineRenderer(snap);
|
|
15418
|
+
const allMatched = fullRun && summary.change === 0 && summary.unchanged > 0;
|
|
15419
|
+
if (current && allMatched && baseline?.fingerprint !== current.fingerprint && !process.env.CI) {
|
|
15420
|
+
await writeSnapshotRenderer(snapshotFile, current);
|
|
15421
|
+
process.stdout.write(
|
|
15422
|
+
`[screentest] recorded renderer ${describeRenderer(current)} in ${relative(projectRoot, snapshotFile)}` + (baseline ? ` (was ${describeRenderer(baseline)})` : "") + ` \u2014 every screenshot matched under it. Commit it with the baselines.
|
|
15423
|
+
`
|
|
15424
|
+
);
|
|
15425
|
+
baseline = current;
|
|
15426
|
+
}
|
|
15427
|
+
const mismatch = !!current && !!baseline && baseline.fingerprint !== current.fingerprint && summary.change > 0 && summary.change >= summary.unchanged;
|
|
15428
|
+
if (current) doc.renderer = { current, baseline, mismatch };
|
|
15372
15429
|
await fs4.mkdir(cacheDir, { recursive: true });
|
|
15373
15430
|
await fs4.writeFile(docFile, JSON.stringify(doc, null, 2));
|
|
15374
15431
|
const total = countLeaves(doc);
|
|
15375
|
-
|
|
15432
|
+
if (mismatch && current && baseline) {
|
|
15433
|
+
process.stderr.write(
|
|
15434
|
+
`
|
|
15435
|
+
[screentest] RENDERER CHANGED \u2014 the diffs below are likely not app changes.
|
|
15436
|
+
[screentest] baselines: ${describeRenderer(baseline)}
|
|
15437
|
+
[screentest] this run: ${describeRenderer(current)}
|
|
15438
|
+
[screentest] Re-run with the baseline renderer, or accept everything to
|
|
15439
|
+
[screentest] move the baselines to this one.
|
|
15440
|
+
|
|
15441
|
+
`
|
|
15442
|
+
);
|
|
15443
|
+
} else if (current && !baseline && summary.change > 0 && summary.unchanged === 0) {
|
|
15444
|
+
process.stderr.write(
|
|
15445
|
+
`
|
|
15446
|
+
[screentest] Every screenshot changed, and ${relative(projectRoot, snapshotFile)}
|
|
15447
|
+
[screentest] records no renderer to compare with. Make sure this run used
|
|
15448
|
+
[screentest] the same renderer as the baselines before accepting.
|
|
15449
|
+
|
|
15450
|
+
`
|
|
15451
|
+
);
|
|
15452
|
+
}
|
|
15453
|
+
const deletedSummary = fullRun ? `deleted: ${summary.deleted}, ` : "";
|
|
15376
15454
|
process.stdout.write(
|
|
15377
15455
|
`Wrote ${docFile}
|
|
15378
|
-
${total} diff${total === 1 ? "" : "s"} to review (new: ${summary.new}, change: ${summary.change}, ${deletedSummary}unchanged: ${summary.unchanged}${
|
|
15456
|
+
${total} diff${total === 1 ? "" : "s"} to review (new: ${summary.new}, change: ${summary.change}, ${deletedSummary}unchanged: ${summary.unchanged}${fullRun ? "" : "; deletion detection disabled \u2014 subset run"})
|
|
15379
15457
|
`
|
|
15380
15458
|
);
|
|
15381
15459
|
return total;
|
|
@@ -15392,7 +15470,8 @@ function resolveRunnerPaths(cwd = process.cwd()) {
|
|
|
15392
15470
|
snapshotFile: resolveSnapshotFile(projectRoot),
|
|
15393
15471
|
cacheDir,
|
|
15394
15472
|
actualDir: join4(cacheDir, "actual"),
|
|
15395
|
-
docFile: join4(cacheDir, "doc.json")
|
|
15473
|
+
docFile: join4(cacheDir, "doc.json"),
|
|
15474
|
+
runFile: join4(cacheDir, "run.json")
|
|
15396
15475
|
};
|
|
15397
15476
|
}
|
|
15398
15477
|
function resolveSnapshotFile(projectRoot) {
|
|
@@ -15415,13 +15494,7 @@ function run(cmd, argv) {
|
|
|
15415
15494
|
}
|
|
15416
15495
|
async function runReview() {
|
|
15417
15496
|
const paths = resolveRunnerPaths();
|
|
15418
|
-
const total = await generateDoc(
|
|
15419
|
-
paths.projectRoot,
|
|
15420
|
-
paths.snapshotFile,
|
|
15421
|
-
paths.actualDir,
|
|
15422
|
-
paths.docFile,
|
|
15423
|
-
paths.cacheDir
|
|
15424
|
-
);
|
|
15497
|
+
const total = await generateDoc(paths);
|
|
15425
15498
|
if (total === 0) {
|
|
15426
15499
|
process.stdout.write("Nothing to review \u2014 all snapshots match.\n");
|
|
15427
15500
|
return 0;
|
|
@@ -15477,9 +15550,9 @@ Tip: add a script to package.json so you can just \`npm run screentest\`:
|
|
|
15477
15550
|
// src/daemon.ts
|
|
15478
15551
|
import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
|
|
15479
15552
|
import { existsSync as existsSync4 } from "fs";
|
|
15553
|
+
import { request } from "http";
|
|
15480
15554
|
import { dirname as dirname6, resolve as resolve8 } from "path";
|
|
15481
15555
|
import { fileURLToPath as fileURLToPath4 } from "url";
|
|
15482
|
-
import { createConnection } from "net";
|
|
15483
15556
|
var IMAGE_NAME = "cevek/screentest-firefox";
|
|
15484
15557
|
var IMAGE_TAG = "pw-1.60.0";
|
|
15485
15558
|
var FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_TAG}`;
|
|
@@ -15487,23 +15560,27 @@ var CONTAINER_NAME = "screentest-firefox";
|
|
|
15487
15560
|
var PORT = 5180;
|
|
15488
15561
|
var WS_PATH = "screentest-firefox";
|
|
15489
15562
|
var WS_ENDPOINT = `ws://localhost:${PORT}/${WS_PATH}`;
|
|
15563
|
+
var START_TIMEOUT_MS = 3e4;
|
|
15490
15564
|
function run2(cmd, argv) {
|
|
15491
15565
|
return new Promise((resolveExit) => {
|
|
15492
15566
|
const p = spawn2(cmd, argv, { stdio: "inherit" });
|
|
15567
|
+
p.on("error", () => resolveExit(127));
|
|
15493
15568
|
p.on("exit", (code) => resolveExit(code ?? 0));
|
|
15494
15569
|
});
|
|
15495
15570
|
}
|
|
15496
15571
|
function daemonState() {
|
|
15497
15572
|
const ps = spawnSync2(
|
|
15498
15573
|
"docker",
|
|
15499
|
-
["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.
|
|
15574
|
+
["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}}"],
|
|
15500
15575
|
{ stdio: "pipe", encoding: "utf8" }
|
|
15501
15576
|
);
|
|
15502
|
-
|
|
15503
|
-
if (
|
|
15504
|
-
|
|
15505
|
-
|
|
15506
|
-
|
|
15577
|
+
if (ps.error) return { state: "no-docker", reason: ps.error.message };
|
|
15578
|
+
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
|
+
if (status === "created" || status === "restarting" || status === "removing") {
|
|
15583
|
+
return { state: "transitional", status };
|
|
15507
15584
|
}
|
|
15508
15585
|
const img = spawnSync2("docker", ["image", "inspect", FULL_IMAGE], { stdio: "pipe" });
|
|
15509
15586
|
if (img.status !== 0) return { state: "missing-image" };
|
|
@@ -15540,75 +15617,115 @@ async function buildImage() {
|
|
|
15540
15617
|
}
|
|
15541
15618
|
return true;
|
|
15542
15619
|
}
|
|
15543
|
-
function
|
|
15620
|
+
function probeServer() {
|
|
15544
15621
|
return new Promise((resolveProbe) => {
|
|
15545
|
-
const
|
|
15546
|
-
|
|
15547
|
-
|
|
15622
|
+
const req = request({ host: "127.0.0.1", port: PORT, path: `/${WS_PATH}`, timeout: 1e3 });
|
|
15623
|
+
req.once("response", (res) => {
|
|
15624
|
+
res.resume();
|
|
15548
15625
|
resolveProbe(true);
|
|
15549
15626
|
});
|
|
15550
|
-
|
|
15627
|
+
req.once("timeout", () => req.destroy());
|
|
15628
|
+
req.once("error", () => resolveProbe(false));
|
|
15629
|
+
req.end();
|
|
15551
15630
|
});
|
|
15552
15631
|
}
|
|
15553
15632
|
async function waitForReady(timeoutMs = 1e4) {
|
|
15554
15633
|
const start = Date.now();
|
|
15555
15634
|
while (Date.now() - start < timeoutMs) {
|
|
15556
|
-
if (await
|
|
15557
|
-
await
|
|
15635
|
+
if (await probeServer()) return true;
|
|
15636
|
+
await sleep(150);
|
|
15558
15637
|
}
|
|
15559
15638
|
return false;
|
|
15560
15639
|
}
|
|
15561
|
-
|
|
15562
|
-
|
|
15563
|
-
|
|
15564
|
-
|
|
15565
|
-
|
|
15566
|
-
|
|
15640
|
+
function sleep(ms) {
|
|
15641
|
+
return new Promise((r) => setTimeout(r, ms));
|
|
15642
|
+
}
|
|
15643
|
+
function assertUsable(s) {
|
|
15644
|
+
if (s.state === "no-docker") {
|
|
15645
|
+
throw new Error(
|
|
15646
|
+
`docker is not available \u2014 screentest renders only in the pinned Firefox
|
|
15647
|
+
container (${FULL_IMAGE}). Start Docker, then re-run.
|
|
15648
|
+
docker said: ${s.reason}
|
|
15649
|
+
`
|
|
15650
|
+
);
|
|
15651
|
+
}
|
|
15652
|
+
if (s.state === "paused") {
|
|
15653
|
+
throw new Error(`screentest-firefox daemon is paused.
|
|
15654
|
+
\u2192 docker unpause ${CONTAINER_NAME}
|
|
15655
|
+
`);
|
|
15656
|
+
}
|
|
15657
|
+
if (s.state === "running" && s.image !== FULL_IMAGE) {
|
|
15658
|
+
throw new Error(
|
|
15659
|
+
`screentest-firefox daemon is running, but on a different image:
|
|
15567
15660
|
running: ${s.image}
|
|
15568
15661
|
this @cevek/screentest wants: ${FULL_IMAGE}
|
|
15569
15662
|
\u2192 stop it first: screentest stop
|
|
15570
15663
|
\u2192 then re-run: screentest serve
|
|
15664
|
+
`
|
|
15665
|
+
);
|
|
15666
|
+
}
|
|
15667
|
+
}
|
|
15668
|
+
function startContainer() {
|
|
15669
|
+
spawnSync2("docker", ["rm", CONTAINER_NAME], { stdio: "pipe" });
|
|
15670
|
+
const r = spawnSync2(
|
|
15671
|
+
"docker",
|
|
15672
|
+
["run", "-d", "--rm", "--name", CONTAINER_NAME, "--network=host", FULL_IMAGE],
|
|
15673
|
+
{ stdio: "pipe", encoding: "utf8" }
|
|
15674
|
+
);
|
|
15675
|
+
return { ok: !r.error && r.status === 0, stderr: r.stderr?.trim() ?? String(r.error) };
|
|
15676
|
+
}
|
|
15677
|
+
async function ensureDaemon() {
|
|
15678
|
+
const deadline = Date.now() + START_TIMEOUT_MS;
|
|
15679
|
+
let started = false;
|
|
15680
|
+
let lastError = "";
|
|
15681
|
+
for (; ; ) {
|
|
15682
|
+
const s = daemonState();
|
|
15683
|
+
assertUsable(s);
|
|
15684
|
+
if (s.state === "running") {
|
|
15685
|
+
if (await waitForReady()) return { started };
|
|
15686
|
+
spawnSync2("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
|
|
15687
|
+
throw new Error(
|
|
15688
|
+
`screentest-firefox daemon container is up but never answered on port ${PORT}.
|
|
15571
15689
|
`
|
|
15572
15690
|
);
|
|
15573
|
-
return 1;
|
|
15574
15691
|
}
|
|
15575
|
-
|
|
15576
|
-
|
|
15577
|
-
|
|
15578
|
-
}
|
|
15579
|
-
|
|
15580
|
-
|
|
15581
|
-
|
|
15582
|
-
|
|
15583
|
-
|
|
15692
|
+
if (Date.now() > deadline) {
|
|
15693
|
+
throw new Error(
|
|
15694
|
+
`screentest-firefox daemon did not come up within ${START_TIMEOUT_MS / 1e3}s` + (s.state === "transitional" ? ` (container stuck in "${s.status}")` : "") + (lastError ? `:
|
|
15695
|
+
${lastError}` : "") + `
|
|
15696
|
+
`
|
|
15697
|
+
);
|
|
15698
|
+
}
|
|
15699
|
+
if (s.state === "missing-image" && !await buildImage()) {
|
|
15700
|
+
throw new Error(`could not build ${FULL_IMAGE}
|
|
15584
15701
|
`);
|
|
15585
|
-
|
|
15586
|
-
"
|
|
15587
|
-
|
|
15588
|
-
"--rm",
|
|
15589
|
-
"--name",
|
|
15590
|
-
CONTAINER_NAME,
|
|
15591
|
-
"--network=host",
|
|
15592
|
-
FULL_IMAGE
|
|
15593
|
-
]);
|
|
15594
|
-
if (code !== 0) {
|
|
15595
|
-
process.stderr.write(`docker run failed (exit ${code})
|
|
15702
|
+
}
|
|
15703
|
+
if (s.state === "stopped" || s.state === "missing-image") {
|
|
15704
|
+
if (!started) process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
|
|
15596
15705
|
`);
|
|
15597
|
-
|
|
15706
|
+
const r = startContainer();
|
|
15707
|
+
if (r.ok) started = true;
|
|
15708
|
+
else lastError = r.stderr;
|
|
15709
|
+
}
|
|
15710
|
+
await sleep(300);
|
|
15598
15711
|
}
|
|
15599
|
-
|
|
15600
|
-
|
|
15601
|
-
|
|
15602
|
-
|
|
15712
|
+
}
|
|
15713
|
+
async function startDaemon() {
|
|
15714
|
+
try {
|
|
15715
|
+
const { started } = await ensureDaemon();
|
|
15716
|
+
process.stdout.write(
|
|
15717
|
+
`screentest-firefox daemon ${started ? "ready" : "already running"} at ${WS_ENDPOINT}
|
|
15718
|
+
`
|
|
15719
|
+
);
|
|
15720
|
+
return 0;
|
|
15721
|
+
} catch (err) {
|
|
15722
|
+
process.stderr.write(err instanceof Error ? err.message : String(err));
|
|
15603
15723
|
return 1;
|
|
15604
15724
|
}
|
|
15605
|
-
process.stdout.write(`screentest-firefox daemon ready at ${WS_ENDPOINT}
|
|
15606
|
-
`);
|
|
15607
|
-
return 0;
|
|
15608
15725
|
}
|
|
15609
15726
|
async function stopDaemon() {
|
|
15610
15727
|
const s = daemonState();
|
|
15611
|
-
if (s.state !== "running") {
|
|
15728
|
+
if (s.state !== "running" && s.state !== "paused") {
|
|
15612
15729
|
process.stdout.write("screentest-firefox daemon is not running\n");
|
|
15613
15730
|
return 0;
|
|
15614
15731
|
}
|
|
@@ -15618,6 +15735,26 @@ async function stopDaemon() {
|
|
|
15618
15735
|
}
|
|
15619
15736
|
async function printStatus() {
|
|
15620
15737
|
const s = daemonState();
|
|
15738
|
+
if (s.state === "no-docker") {
|
|
15739
|
+
process.stdout.write(
|
|
15740
|
+
`screentest-firefox daemon: unknown (docker is not available: ${s.reason})
|
|
15741
|
+
`
|
|
15742
|
+
);
|
|
15743
|
+
return 1;
|
|
15744
|
+
}
|
|
15745
|
+
if (s.state === "paused") {
|
|
15746
|
+
process.stdout.write(
|
|
15747
|
+
`screentest-firefox daemon: paused
|
|
15748
|
+
\u2192 docker unpause ${CONTAINER_NAME}
|
|
15749
|
+
`
|
|
15750
|
+
);
|
|
15751
|
+
return 0;
|
|
15752
|
+
}
|
|
15753
|
+
if (s.state === "transitional") {
|
|
15754
|
+
process.stdout.write(`screentest-firefox daemon: ${s.status}
|
|
15755
|
+
`);
|
|
15756
|
+
return 0;
|
|
15757
|
+
}
|
|
15621
15758
|
if (s.state === "running") {
|
|
15622
15759
|
const match = s.image === FULL_IMAGE ? "(matches this @cevek/screentest)" : "(MISMATCH!)";
|
|
15623
15760
|
process.stdout.write(
|
|
@@ -15640,14 +15777,14 @@ async function printStatus() {
|
|
|
15640
15777
|
if (s.state === "stopped") {
|
|
15641
15778
|
process.stdout.write(
|
|
15642
15779
|
`screentest-firefox daemon: stopped (image ${FULL_IMAGE} exists)
|
|
15643
|
-
|
|
15780
|
+
starts automatically on the next test run, or now with: screentest serve
|
|
15644
15781
|
`
|
|
15645
15782
|
);
|
|
15646
15783
|
return 0;
|
|
15647
15784
|
}
|
|
15648
15785
|
process.stdout.write(
|
|
15649
15786
|
`screentest-firefox daemon: not installed (image ${FULL_IMAGE} missing)
|
|
15650
|
-
|
|
15787
|
+
built + started automatically on the next test run, or now with: screentest serve
|
|
15651
15788
|
`
|
|
15652
15789
|
);
|
|
15653
15790
|
return 0;
|
|
@@ -15940,7 +16077,8 @@ function printHelp() {
|
|
|
15940
16077
|
"",
|
|
15941
16078
|
" screentest serve start the shared Firefox browser-server daemon",
|
|
15942
16079
|
" (builds the image on first run). One daemon per",
|
|
15943
|
-
" machine \u2014 used by every project",
|
|
16080
|
+
" machine \u2014 used by every project. Test runs start",
|
|
16081
|
+
" it on their own; `serve` just does it up front",
|
|
15944
16082
|
" screentest stop stop the daemon",
|
|
15945
16083
|
" screentest status show whether the daemon is running",
|
|
15946
16084
|
"",
|
|
@@ -15963,8 +16101,8 @@ function printHelp() {
|
|
|
15963
16101
|
"Running screenshot tests:",
|
|
15964
16102
|
" Add to your package.json scripts (or run directly):",
|
|
15965
16103
|
' "screentest": "vitest run --config vitest.screentest.config.ts"',
|
|
15966
|
-
" The vitest globalSetup we ship handles pre-flight (wipe actualDir,
|
|
15967
|
-
" the daemon) and post-flight (build doc.json, auto-launch the review UI",
|
|
16104
|
+
" The vitest globalSetup we ship handles pre-flight (wipe actualDir, start",
|
|
16105
|
+
" the daemon if needed) and post-flight (build doc.json, auto-launch the review UI",
|
|
15968
16106
|
" if there are diffs).",
|
|
15969
16107
|
"",
|
|
15970
16108
|
"Env vars (UI mode):",
|
package/dist/runner.js
CHANGED
|
@@ -14,7 +14,8 @@ function resolveRunnerPaths(cwd = process.cwd()) {
|
|
|
14
14
|
snapshotFile: resolveSnapshotFile(projectRoot),
|
|
15
15
|
cacheDir,
|
|
16
16
|
actualDir: join(cacheDir, "actual"),
|
|
17
|
-
docFile: join(cacheDir, "doc.json")
|
|
17
|
+
docFile: join(cacheDir, "doc.json"),
|
|
18
|
+
runFile: join(cacheDir, "run.json")
|
|
18
19
|
};
|
|
19
20
|
}
|
|
20
21
|
function resolveSnapshotFile(projectRoot) {
|
|
@@ -198,15 +199,19 @@ async function compareSnapshot(target, name, opts = {}) {
|
|
|
198
199
|
// src/runner/browser.ts
|
|
199
200
|
import { inject } from "vitest";
|
|
200
201
|
import { firefox } from "playwright";
|
|
202
|
+
|
|
203
|
+
// src/runner/context-defaults.ts
|
|
204
|
+
var CONTEXT_DEFAULTS = {
|
|
205
|
+
viewport: { width: 1280, height: 800 },
|
|
206
|
+
deviceScaleFactor: 1,
|
|
207
|
+
reducedMotion: "reduce"
|
|
208
|
+
};
|
|
209
|
+
|
|
210
|
+
// src/runner/browser.ts
|
|
201
211
|
async function newPage(opts = {}) {
|
|
202
212
|
const wsEndpoint = inject("wsEndpoint");
|
|
203
213
|
const browser = await firefox.connect(wsEndpoint);
|
|
204
|
-
const ctx = await browser.newContext({
|
|
205
|
-
viewport: { width: 1280, height: 800 },
|
|
206
|
-
deviceScaleFactor: 1,
|
|
207
|
-
reducedMotion: "reduce",
|
|
208
|
-
...opts
|
|
209
|
-
});
|
|
214
|
+
const ctx = await browser.newContext({ ...CONTEXT_DEFAULTS, ...opts });
|
|
210
215
|
const page = await ctx.newPage();
|
|
211
216
|
return {
|
|
212
217
|
ctx,
|