test(scroll): fix the climbing fixture and drop duplicated route-level cases

Author: thymikee

src/daemon/__tests__/scroll-runtime.test.ts

@@ -361,7 +361,12 @@ function untilNodes(targetY: number, hiddenBelow: boolean) {
   ];
 }
 
-test('bound scroll --until stops on the pass whose capture shows the selector on screen', async () => {
+/**
+ * Route-level only: the executor's result envelope, the parse rejection, and admission. The loop's
+ * own behavior — arrival, end-of-content, the pass budget, and every capture refusal — is covered
+ * against the module in `scroll-until.test.ts` rather than duplicated through this harness.
+ */
+test('bound scroll --until reports the passes it spent and the selector it stopped on', async () => {
   const scrolls: string[] = [];
   const frames = [untilNodes(2400, true), untilNodes(1200, true), untilNodes(300, true)];
   const result = await runScroll(
@@ -377,118 +382,12 @@ test('bound scroll --until stops on the pass whose capture shows the selector on
   );
 
   assert.equal(result.until, 'label=Email');
+  assert.equal(result.direction, 'down');
   assert.equal(result.passes, 2);
-  assert.equal(scrolls.length, 2);
+  assert.deepEqual(scrolls, ['down', 'down']);
   assert.match(String(result.message), /Scrolled down 2 passes until label=Email was visible/);
 });
 
-test('bound scroll --until reports the end of the content rather than spending its budget', async () => {
-  await assert.rejects(
-    () =>
-      runScroll(
-        ['down'],
-        { until: 'label=Missing' },
-        {
-          captureSnapshot: async () => ({ nodes: untilNodes(300, false) }),
-          scroll: async () => ({}),
-        },
-      ),
-    (error: unknown) => {
-      assert.ok(error instanceof AppError);
-      assert.equal(error.details?.reason, 'scroll_until_edge_reached');
-      return true;
-    },
-  );
-});
-
-test('bound scroll rejects --until on an edge direction before any device work', async () => {
-  await assert.rejects(
-    () =>
-      runScroll(
-        ['bottom'],
-        { until: 'label=Email' },
-        {
-          captureSnapshot: async () => ({ nodes: untilNodes(300, true) }),
-          scroll: async () => {
-            throw new Error('scroll should be rejected before the backend call');
-          },
-        },
-      ),
-    /scroll bottom already scrolls to the bottom edge and cannot take --until/,
-  );
-});
-
-test('bound scroll --until is refused when the owner advertises no capture', async () => {
-  const resolved = await resolveBoundScrollRuntime({
-    device: IOS_SIMULATOR,
-    positionals: ['down'],
-    context: { until: 'label=Email' } as DaemonCommandContext,
-    ...bindings({ scroll: async () => ({}) }),
-  });
-  assert.equal(resolved.ok, false);
-});
-
-/** Same defect as the command runtime's: a failed read is not evidence that the content ran out. */
-/**
- * The owner's capture result spells the verdict `quality`, which is the shape this route actually
- * receives — an earlier version of this test asserted through `snapshotQuality` and passed while
- * the real field went unread. The scroll spy proves each refusal lands before any gesture, and the
- * sparse tree deliberately has content below the fold, so an edge verdict would be wrong there too.
- */
-test('bound scroll --until reports an unreadable capture as a capture failure, not end-of-content', async () => {
-  let scrolls = 0;
-  await assert.rejects(
-    () =>
-      runScroll(
-        ['down'],
-        { until: 'label=Email' },
-        {
-          captureSnapshot: async () => ({}),
-          scroll: async () => {
-            scrolls += 1;
-            return {};
-          },
-        },
-      ),
-    (error: unknown) => {
-      assert.ok(error instanceof AppError);
-      assert.equal(error.details?.reason, 'scroll_until_capture_unreadable');
-      assert.equal(error.details?.captureRefusal, 'no-capture');
-      return true;
-    },
-  );
-  assert.equal(scrolls, 0);
-});
-
-test('bound scroll --until refuses a sparse capture before matching, edge analysis or scrolling', async () => {
-  let scrolls = 0;
-  await assert.rejects(
-    () =>
-      runScroll(
-        ['down'],
-        { until: 'label=Email' },
-        {
-          captureSnapshot: async () => ({
-            nodes: untilNodes(2400, true),
-            quality: { state: 'sparse', backend: 'tree', reason: 'AX bridge unavailable' },
-          }),
-          scroll: async () => {
-            scrolls += 1;
-            return {};
-          },
-        },
-      ),
-    (error: unknown) => {
-      assert.ok(error instanceof AppError);
-      assert.equal(error.details?.reason, 'scroll_until_capture_unreadable');
-      assert.equal(error.details?.captureRefusal, 'sparse-tree');
-      assert.match(String(error.message), /AX bridge unavailable/);
-      return true;
-    },
-  );
-  assert.equal(scrolls, 0);
-});
-
 test('bound scroll rejects --until on an edge direction before any device work', async () => {
   await assert.rejects(
     () =>
@@ -502,11 +401,11 @@ test('bound scroll rejects --until on an edge direction before any device work',
           },
         },
       ),
-    /scroll bottom already scrolls to the bottom edge and cannot take --until/,
+    /cannot take --until/,
   );
 });
 
-test('bound scroll --until is refused when the owner advertises no capture', async () => {
+test('bound scroll --until is refused at admission when the owner declares no capture', async () => {
   const resolved = await resolveBoundScrollRuntime({
     device: IOS_SIMULATOR,
     positionals: ['down'],
@@ -515,46 +414,3 @@ test('bound scroll --until is refused when the owner advertises no capture', asy
   });
   assert.equal(resolved.ok, false);
 });
-
-/** Same defect as the command runtime's: a failed read is not evidence that the content ran out. */
-test('bound scroll --until reports an unreadable capture as a capture failure, not end-of-content', async () => {
-  await assert.rejects(
-    () =>
-      runScroll(
-        ['down'],
-        { until: 'label=Email' },
-        {
-          captureSnapshot: async () => ({}),
-          scroll: async () => ({}),
-        },
-      ),
-    (error: unknown) => {
-      assert.ok(error instanceof AppError);
-      assert.equal(error.details?.reason, 'scroll_until_capture_unreadable');
-      assert.equal(error.details?.captureRefusal, 'no-capture');
-      return true;
-    },
-  );
-});
-
-test('bound scroll --until refuses a sparse capture rather than trusting its selectors', async () => {
-  await assert.rejects(
-    () =>
-      runScroll(
-        ['down'],
-        { until: 'label=Email' },
-        {
-          captureSnapshot: async () => ({
-            nodes: untilNodes(2400, true),
-            snapshotQuality: { state: 'sparse', backend: 'tree', reason: 'AX bridge unavailable' },
-          }),
-          scroll: async () => ({}),
-        },
-      ),
-    (error: unknown) => {
-      assert.ok(error instanceof AppError);
-      assert.equal(error.details?.captureRefusal, 'sparse-tree');
-      return true;
-    },
-  );
-});

test/integration/provider-scenarios/scroll-until.test.ts

@@ -13,6 +13,9 @@ import { withProviderScenarioResource } from './harness.ts';
  * rather than on injected gestures because the Android gesture path runs through the persistent
  * helper, not an adb shell command the world can count.
  */
+/** Two screens below the fold, climbing one screen per capture: visible on the third capture. */
+const ARRIVAL_PASSES = 2;
+
 function climbingRow(): () => number {
   let captures = 0;
   return () => {
@@ -23,16 +26,20 @@ function climbingRow(): () => number {
 }
 
 function climbingHierarchy(targetTop: () => number): () => string {
-  return () =>
-    [
+  return () => {
+    // Read the stateful position ONCE: calling it per bound advanced the row twice per capture and
+    // produced an inverted rectangle on the first one.
+    const top = targetTop();
+    return [
       '<?xml version="1.0" encoding="UTF-8"?>',
       '<hierarchy rotation="0">',
       '  <node index="0" text="" resource-id="com.android.settings:id/main_content_scrollable_container" class="android.widget.ScrollView" package="com.android.settings" content-desc="" bounds="[0,0][390,600]" clickable="false" enabled="true">',
       '    <node index="0" text="Apps" resource-id="android:id/title" class="android.widget.TextView" package="com.android.settings" content-desc="" bounds="[24,124][152,178]" clickable="true" enabled="true" focusable="true" focused="false" />',
-      `    <node index="1" text="Terms" resource-id="com.android.settings:id/terms" class="android.widget.TextView" package="com.android.settings" content-desc="" bounds="[24,${targetTop()}][374,${targetTop() + 54}]" clickable="true" enabled="true" focusable="true" focused="false" />`,
+      `    <node index="1" text="Terms" resource-id="com.android.settings:id/terms" class="android.widget.TextView" package="com.android.settings" content-desc="" bounds="[24,${top}][374,${top + 54}]" clickable="true" enabled="true" focusable="true" focused="false" />`,
       '  </node>',
       '</hierarchy>',
     ].join('\n');
+  };
 }
 
 test('Provider-backed integration scroll --until stops on the capture that brings the target on screen', async () => {
@@ -48,18 +55,15 @@ test('Provider-backed integration scroll --until stops on the capture that bring
         ...world.selection,
       });
 
-      const passes = typeof result.passes === 'number' ? result.passes : -1;
       assert.equal(result.until, 'text=Terms');
       assert.equal(result.direction, 'down');
-      assert.ok(
-        passes >= 1,
-        `expected at least one pass to reach the off-screen row, saw ${passes}`,
-      );
-      assert.match(String(result.message), /until text=Terms was visible/);
-      // Stopped on arrival rather than running the budget out.
-      assert.ok(
-        passes < SCROLL_UNTIL_PASS_LIMIT,
-        `expected the loop to stop on arrival, spent ${passes} passes`,
+      // An exact count is what proves repeated scrolling on valid geometry, rather than a lucky
+      // first capture or a budget burned to the limit.
+      assert.equal(result.passes, ARRIVAL_PASSES);
+      assert.ok(ARRIVAL_PASSES < SCROLL_UNTIL_PASS_LIMIT);
+      assert.match(
+        String(result.message),
+        new RegExp(`Scrolled down ${ARRIVAL_PASSES} passes until text=Terms was visible`),
       );
     },
   );