donobu 5.60.3 → 5.60.5

package/dist/lib/test/healRerunGate.js

@@ -23,7 +23,15 @@
  *     `expandTargetsWithSerialCompanions`) using the `serialScoped` flags the
  *     Donobu reporter recorded during the initial run — the runner process
  *     sees the suite tree; the worker (where this gate runs) does not.
- *   - Declared dependency projects, which Playwright always runs in full.
+ *   - Declared dependency (setup) projects, in full. Playwright schedules them
+ *     because a target project lists them in `dependencies`, and the rerun
+ *     command only ever passes `--project=<target>`, so any project that runs
+ *     and is NOT a heal-target project is, by construction, such a dependency
+ *     project. The gate exempts every test whose project is not a target
+ *     project, so the auth/storage-state and fixture seeding those projects
+ *     perform actually runs. (A prior version skipped them too — every test
+ *     not literally in the plan — which broke targets that depend on the
+ *     `.auth` storage state a setup project produces.)
  *
  * Implicit ordering (checkpoint files between plain tests, cross-file state
  * with `workers: 1`) is deliberately NOT honored: tests relying on it will
@@ -41,7 +49,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPlanIndex = buildPlanIndex;
-exports.computeGatedProjects = computeGatedProjects;
 exports.shouldRunDuringHealRerun = shouldRunDuringHealRerun;
 exports.expandTargetsWithSerialCompanions = expandTargetsWithSerialCompanions;
 exports.resetHealRerunPlanCacheForTesting = resetHealRerunPlanCacheForTesting;
@@ -52,52 +59,47 @@ const envVars_1 = require("../../envVars");
 const model_1 = require("../../reporter/model");
 const Logger_1 = require("../../utils/Logger");
 function buildPlanIndex(plan) {
-    const index = new Map();
+    const byFile = new Map();
+    const targetProjects = new Set();
     for (const target of plan.targets ?? []) {
         if (!target?.file || !target?.title) {
             continue;
         }
         const file = path_1.default.resolve(target.file);
-        if (!index.has(file)) {
-            index.set(file, new Set());
+        if (!byFile.has(file)) {
+            byFile.set(file, new Set());
         }
-        index.get(file).add(target.title);
-    }
-    return index;
-}
-/**
- * The projects the rerun gate should apply to: the heal targets' own
- * projects, minus any project that is a declared (transitive) dependency of
- * another target project — the dependency declaration wins, and that project
- * runs in full.
- */
-function computeGatedProjects(targetProjects, projectDependencies) {
-    const targets = [
-        ...new Set(targetProjects.filter((name) => Boolean(name))),
-    ];
-    if (!projectDependencies) {
-        return targets;
-    }
-    // Every project reachable through any target's declared dependency chain.
-    const reachable = new Set();
-    const visit = (name) => {
-        for (const dependency of projectDependencies[name] ?? []) {
-            if (!reachable.has(dependency)) {
-                reachable.add(dependency);
-                visit(dependency);
-            }
+        byFile.get(file).add(target.title);
+        if (target.projectName) {
+            targetProjects.add(target.projectName);
         }
-    };
-    targets.forEach(visit);
-    return targets.filter((name) => !reachable.has(name));
+    }
+    return { byFile, targetProjects };
 }
 /**
- * Pure decision: should the test in `file` with `title` actually execute
- * during the heal rerun? The plan is fully explicit — serial companions were
- * already expanded into it by the orchestrator.
+ * Pure decision: should the test in `file` with `title` (owned by project
+ * `projectName`) actually execute during the heal rerun? The plan is fully
+ * explicit — serial companions were already expanded into it by the
+ * orchestrator.
+ *
+ * Dependency/setup projects (auth login, fixture seeding, …) are pulled in by
+ * Playwright because a target project declares them in `dependencies`. They
+ * are never themselves heal targets, but their tests MUST run so the state the
+ * targets depend on (storage-state auth files, seeded documents) is in place
+ * before the rerun. The rerun command only ever passes `--project=<target>`,
+ * so any project Playwright runs that is not a target project is, by
+ * construction, such a dependency project — run it in full. Guarded on a
+ * non-empty target-project set so the gate degrades to pure file+title
+ * matching when project names are unavailable.
  */
 function shouldRunDuringHealRerun(params) {
-    const titles = params.index.get(path_1.default.resolve(params.file));
+    const { index, projectName } = params;
+    if (projectName !== undefined &&
+        index.targetProjects.size > 0 &&
+        !index.targetProjects.has(projectName)) {
+        return true;
+    }
+    const titles = index.byFile.get(path_1.default.resolve(params.file));
     return titles?.has(params.title) ?? false;
 }
 /**
@@ -160,61 +162,47 @@ function expandTargetsWithSerialCompanions(targets, initialReport) {
     }
     return expanded;
 }
-let cachedPlan;
-function loadPlan(planPathOverride) {
-    if (planPathOverride === undefined && cachedPlan !== undefined) {
-        return cachedPlan;
+let cachedPlanIndex;
+function getPlanIndex(planPathOverride) {
+    if (planPathOverride === undefined && cachedPlanIndex !== undefined) {
+        return cachedPlanIndex;
     }
     const planPath = planPathOverride ?? envVars_1.env.data.DONOBU_AUTO_HEAL_PLAN_PATH;
-    let loaded = null;
+    let index = null;
     if (planPath) {
         try {
             const raw = fs_1.default.readFileSync(planPath, 'utf8');
-            const plan = JSON.parse(raw);
-            loaded = {
-                index: buildPlanIndex(plan),
-                gatedProjects: new Set(plan.gatedProjects ??
-                    // Older plans carry no project list — gate the targets' own
-                    // projects, leaving everything else (dependencies) untouched.
-                    plan.targets
-                        ?.map((target) => target.projectName)
-                        .filter((name) => Boolean(name)) ??
-                    []),
-            };
+            index = buildPlanIndex(JSON.parse(raw));
         }
         catch (error) {
             Logger_1.appLogger.warn(`Auto-heal rerun plan at ${planPath} could not be read; running all collected tests.`, error);
-            loaded = null;
+            index = null;
         }
     }
     if (planPathOverride === undefined) {
-        cachedPlan = loaded;
+        cachedPlanIndex = index;
     }
-    return loaded;
+    return index;
 }
 /** Test-only: reset the memoized plan so each test can load its own. */
 function resetHealRerunPlanCacheForTesting() {
-    cachedPlan = undefined;
+    cachedPlanIndex = undefined;
 }
 /**
  * Called from the Donobu auto fixture before any browser fixture initializes.
- * Outside heal reruns this is a no-op. During a rerun, tests in gated
- * projects that are outside the plan are annotated and skipped on the spot —
- * no context, no page, no cost. Tests in ungated projects (declared
- * dependencies of the targets, teardown projects) always run.
+ * Outside heal reruns this is a no-op. During a rerun, tests outside the plan
+ * are annotated and skipped on the spot — no context, no page, no cost.
  */
 function maybeSkipForHealRerun(testInfo, options) {
-    const plan = loadPlan(options?.planPath);
-    if (!plan) {
-        return;
-    }
-    if (!plan.gatedProjects.has(testInfo.project.name)) {
+    const index = getPlanIndex(options?.planPath);
+    if (!index) {
         return;
     }
     const shouldRun = shouldRunDuringHealRerun({
-        index: plan.index,
+        index,
         file: testInfo.file,
         title: testInfo.title,
+        projectName: testInfo.project?.name,
     });
     if (shouldRun) {
         return;

package/dist/lib/test/testExtension.js

@@ -122,28 +122,44 @@ async function waitForPendingVideoPersists(timeoutMs) {
  *   - `'on'`                       → always retain → always persist.
  *   - `'retain-on-failure'`        → retain only on non-passing → persist
  *                                    only when status !== 'passed'.
+ *   - `'retain-on-first-failure'`  → recorded only on the first run; a video
+ *                                    only exists when that run failed → same
+ *                                    persist condition as 'retain-on-failure'.
+ *   - `'retain-on-failure-and-retries'` → retain on non-passing OR on any
+ *                                    retry → persist when status !== 'passed'
+ *                                    or retry > 0.
  *   - `'on-first-retry'`           → recorded only on retries; if a video
  *                                    exists, we're on a retry → persist.
+ *   - `'on-all-retries'`           → recorded on every retry; same as
+ *                                    'on-first-retry' once a video exists.
  *   - any unknown future mode      → conservatively SKIP, with a warn log.
  *                                    Better to under-persist than violate
  *                                    user intent for a mode we don't yet
  *                                    understand.
  */
-function shouldPersistVideo(videoOption, status) {
+function shouldPersistVideo(videoOption, status, retry) {
     const mode = typeof videoOption === 'string' ? videoOption : videoOption?.mode;
     switch (mode) {
         case 'on':
             return true;
         case 'on-first-retry':
-            // When set, Playwright only records on retries; if a video exists
-            // it implies we're on a retry — always retain.
+        case 'on-all-retries':
+            // Playwright only records on retries under these modes; if a video
+            // exists it implies we're on a retry — always retain.
             return true;
         case 'retry-with-video':
             // Deprecated alias for 'on-first-retry' that Playwright still
             // accepts on the type. Same retain semantics.
             return true;
         case 'retain-on-failure':
+        case 'retain-on-first-failure':
+            // Both record up front and discard on a passing run. ('first-failure'
+            // only records the first run, but a video existing already implies
+            // that's the run we're persisting.)
             return status !== 'passed';
+        case 'retain-on-failure-and-retries':
+            // Records every run; kept on failure OR on any retry attempt.
+            return status !== 'passed' || retry > 0;
         case 'off':
         case undefined:
             return false;
@@ -182,7 +198,7 @@ function persistVideoIfApplicable(page, testInfo, videoOption) {
         // and this isn't a retry, etc. Nothing to do.
         return;
     }
-    if (!shouldPersistVideo(videoOption, testInfo.status)) {
+    if (!shouldPersistVideo(videoOption, testInfo.status, testInfo.retry)) {
         Logger_1.appLogger.info(`Skipping video persist for flow ${flowId}: video mode ` +
             `"${describeVideoMode(videoOption)}" + status "${testInfo.status}" ` +
             `means Playwright will discard the file and we'd be violating user ` +

package/dist/managers/InteractionVisualizer.d.ts

@@ -5,11 +5,16 @@ export declare class InteractionVisualizer {
     private static readonly TIP_X;
     private static readonly TIP_Y;
     private static readonly SVG_MOUSE;
-    private static readonly SVG_MOUSE_JSON;
-    private static readonly CSS;
-    private static readonly CONTAINER_ID;
-    private cursorPos;
+    /** Message tooltip box styling — mirrors the legacy `.donobu-message` rule. */
+    private static readonly MESSAGE_MAX_WIDTH;
+    private static readonly MESSAGE_MARGIN;
+    /**
+     * Per-page cursor state. Keyed weakly so closed/GC'd pages drop out without
+     * us tracking page lifecycles.
+     */
+    private readonly states;
     constructor(defaultMessageDurationMillis: number);
+    private static escapeHtml;
     /**
      * Moves the virtual cursor to the center of the specified element and optionally displays a message.
      *
@@ -22,39 +27,45 @@ export declare class InteractionVisualizer {
      * @returns Promise that resolves when the cursor movement and message display are complete
      *
      * @remarks
-     * - The target element will be scrolled into view if necessary
      * - The cursor animates smoothly to the element's center point
      * - Messages are positioned automatically to avoid viewport edges
-     * - The virtual cursor does not interfere with actual page interactions
+     * - Overlays are `pointer-events: none`, so they never intercept real interactions
      */
     pointAt(page: Page, locator?: Pick<Locator, 'boundingBox'>, message?: string, duration?: number): Promise<void>;
     /**
-     * Shows the virtual mouse cursor on the page.
+     * Shows the virtual mouse cursor on the page at its current position.
      *
      * @param page - The Playwright page instance where the cursor will be displayed.
-     *
      * @returns Promise that resolves when the cursor is shown.
-     *
-     * @remarks
-     * - If the cursor doesn't exist yet, it will be created.
-     * - The cursor will be made visible with a smooth opacity transition.
      */
     showMouse(page: Page): Promise<void>;
     /**
      * Hides the virtual mouse cursor on the page.
      *
      * @param page - The Playwright page instance where the cursor is displayed.
-     *
-     * @returns Promise that resolves when the cursor is hidden
-     *
-     * @remarks
-     * - The cursor will be hidden with a smooth opacity transition
-     * - The cursor element remains in the DOM but becomes invisible
+     * @returns Promise that resolves when the cursor is hidden.
      */
     hideMouse(page: Page): Promise<void>;
-    private ensureContainer;
-    private ensureCursor;
-    private moveCursor;
+    private getState;
+    /**
+     * Replaces the sticky cursor overlay with one positioned at `to`, gliding
+     * from `from` when `animMs > 0`. We show the new overlay before disposing
+     * the old one to avoid a visible flicker, and tolerate a stale disposable
+     * (e.g. cleared by a navigation) by swallowing its dispose error.
+     */
+    private renderCursor;
     private showMessage;
+    /**
+     * Builds the cursor overlay markup: the arrow SVG plus a `@keyframes` glide
+     * from the previous position and a one-shot ripple at the arrow tip.
+     */
+    private buildCursorHtml;
+    /**
+     * Builds the message tooltip markup, positioned near `target` and clamped
+     * inside the viewport. Without being able to measure the rendered box, we
+     * keep it on-screen with a conservative max-width clamp and anchor it above
+     * the cursor (via `translateY(-100%)`) when the cursor sits low in the page.
+     */
+    private buildMessageHtml;
 }
 //# sourceMappingURL=InteractionVisualizer.d.ts.map