test: make hard-coded caps overridable behind seams (#1781 B5)

HarmonyOS snapshot gains a maxNodes seam (mirroring the Android helper
and Linux AT-SPI capture options) so the node cap's truncation signal is
exercised below the 5,000 default; the durable descriptor JSON node cap
gets its boundary test alongside the existing depth one.

Author: thymikee

packages/capture-kit/src/durable-json.test.ts

@@ -12,6 +12,14 @@ test('bounded durable JSON rejects cycles and excessive depth', () => {
   assert.equal(isBoundedJsonObject(nested), false);
 });
 
+test('bounded durable JSON rejects a wide, shallow document past the node cap', () => {
+  // Depth 2 everywhere, so only the node budget can reject it: the root plus
+  // one array plus 4,096 empty objects is 4,098 nodes.
+  const wide = { items: Array.from({ length: 4_096 }, () => ({})) };
+  assert.equal(isBoundedJsonObject(wide), false);
+  assert.equal(isBoundedJsonObject({ items: wide.items.slice(0, 4_000) }), true);
+});
+
 test('validated durable JSON freezes without recursively revalidating every subtree', () => {
   let reads = 0;
   const leaf = Object.defineProperty({}, 'value', {

src/platforms/harmonyos/__tests__/snapshot.test.ts

@@ -1,6 +1,35 @@
 import assert from 'node:assert/strict';
-import { test } from 'vitest';
-import { parseArkUiBounds, parseHarmonyLayout } from '../snapshot.ts';
+import fs from 'node:fs';
+import { beforeEach, test, vi } from 'vitest';
+
+const { runHarmonyHdc } = vi.hoisted(() => ({ runHarmonyHdc: vi.fn() }));
+
+vi.mock('../hdc.ts', () => ({ runHarmonyHdc }));
+
+import { parseArkUiBounds, parseHarmonyLayout, snapshotHarmony } from '../snapshot.ts';
+
+const DEVICE = {
+  platform: 'harmonyos' as const,
+  id: 'harmony-1',
+  name: 'HarmonyOS test device',
+  kind: 'device' as const,
+  target: 'mobile' as const,
+  booted: true,
+};
+
+beforeEach(() => {
+  runHarmonyHdc.mockReset();
+});
+
+/** Scripts `uitest dumpLayout` + `file recv` so the pulled layout is `layout`. */
+function scriptHarmonyLayoutDump(layout: unknown): void {
+  runHarmonyHdc.mockImplementation(async (_device: unknown, args: string[]) => {
+    if (args[0] === 'file' && args[1] === 'recv') {
+      fs.writeFileSync(args[3] as string, JSON.stringify(layout), 'utf8');
+    }
+    return { exitCode: 0, stdout: '', stderr: '' };
+  });
+}
 
 test('parseArkUiBounds converts API 24 layout bounds into a rectangle', () => {
   assert.deepEqual(parseArkUiBounds('[84,1127][1172,1295]'), {
@@ -15,3 +44,27 @@ test('parseArkUiBounds converts API 24 layout bounds into a rectangle', () => {
 test('parseHarmonyLayout rejects non-object uitest documents', () => {
   assert.throws(() => parseHarmonyLayout('[]'), /invalid layout JSON/i);
 });
+
+test('snapshotHarmony reports truncation once the node cap is hit instead of dropping nodes silently', async () => {
+  scriptHarmonyLayoutDump({
+    attributes: { type: 'root', bounds: '[0,0][1080,2340]' },
+    children: [
+      { attributes: { type: 'Button', text: 'first', clickable: 'true' } },
+      { attributes: { type: 'Button', text: 'second', clickable: 'true' } },
+      { attributes: { type: 'Button', text: 'third', clickable: 'true' } },
+    ],
+  });
+
+  const capped = await snapshotHarmony(DEVICE, { maxNodes: 2 });
+
+  assert.equal(capped.truncated, true);
+  assert.deepEqual(
+    capped.nodes.map((node) => node.value ?? node.type),
+    ['Application', 'first'],
+  );
+  assert.equal(capped.analysis.rawNodeCount, 4);
+
+  const uncapped = await snapshotHarmony(DEVICE);
+  assert.equal(uncapped.truncated, undefined);
+  assert.equal(uncapped.nodes.length, 4);
+});

src/platforms/harmonyos/snapshot.ts

@@ -15,9 +15,16 @@ type ArkUiLayoutNode = {
   children?: ArkUiLayoutNode[];
 };
 
+/**
+ * `maxNodes` bounds the emitted tree; nodes past it are dropped and the
+ * result reports `truncated`. Mirrors the Android helper and Linux AT-SPI
+ * capture seams so the bound is exercisable below the 5,000 default.
+ */
+export type HarmonySnapshotOptions = SnapshotOptions & { maxNodes?: number };
+
 export async function snapshotHarmony(
   device: DeviceInfo,
-  options: SnapshotOptions = {},
+  options: HarmonySnapshotOptions = {},
 ): Promise<{
   nodes: RawSnapshotNode[];
   truncated?: boolean;
@@ -75,7 +82,7 @@ export function parseHarmonyLayout(raw: string): ArkUiLayoutNode {
 
 function buildHarmonySnapshot(
   root: ArkUiLayoutNode,
-  options: SnapshotOptions,
+  options: HarmonySnapshotOptions,
 ): {
   nodes: RawSnapshotNode[];
   truncated?: boolean;
@@ -85,7 +92,7 @@ function buildHarmonySnapshot(
   let rawNodeCount = 0;
   let maxDepth = 0;
   let truncated = false;
-  const maxNodes = MAX_NODES;
+  const maxNodes = options.maxNodes ?? MAX_NODES;
   const walk = (node: ArkUiLayoutNode, depth: number, parentIndex?: number): void => {
     rawNodeCount += 1;
     maxDepth = Math.max(maxDepth, depth);