@deeeed/metamask-harness 0.24.0 → 0.25.0

package/library/actions/mobile/analytics/set_consent.mjs

@@ -0,0 +1,90 @@
+import { evalAsync, navigate, runAdapter } from '../platform/bridge.mjs';
+import { consentParams } from '../../shared/analytics/consent.mjs';
+
+const SWITCH_IDS = {
+  participate: 'metametrics-switch',
+  marketing: 'data-collection-switch',
+};
+
+function toggleExpression(testId, expected, timeoutMs) {
+  return `(async () => {
+    const deadline = Date.now() + ${JSON.stringify(timeoutMs)};
+    let invoked = false;
+    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const find = () => {
+      const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      const rootsFor = hook?.getFiberRoots;
+      if (!hook?.renderers || typeof rootsFor !== 'function') return null;
+      const walk = (fiber) => {
+        if (!fiber) return null;
+        if (fiber.memoizedProps?.testID === ${JSON.stringify(testId)}) return fiber;
+        return walk(fiber.child) || walk(fiber.sibling);
+      };
+      for (const [id] of hook.renderers) {
+        for (const root of rootsFor(id) ?? []) {
+          const match = walk(root.current);
+          if (match) return match;
+        }
+      }
+      return null;
+    };
+    while (Date.now() < deadline) {
+      const target = find();
+      const props = target?.memoizedProps;
+      if (props && Boolean(props.value) === ${JSON.stringify(expected)}) {
+        return { ok: true, testId: ${JSON.stringify(testId)}, changed: invoked };
+      }
+      if (props && !invoked) {
+        if (typeof props.onValueChange !== 'function') {
+          throw new Error('Consent switch has no onValueChange handler: ${testId}');
+        }
+        invoked = true;
+        await props.onValueChange(${JSON.stringify(expected)});
+      }
+      await delay(100);
+    }
+    throw new Error('Timed out setting consent switch ${testId} to ${expected}.');
+  })()`;
+}
+
+function stateExpression(participate, marketing, timeoutMs) {
+  return `(async () => {
+    const deadline = Date.now() + ${JSON.stringify(timeoutMs)};
+    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    while (Date.now() < deadline) {
+      const state = globalThis.store?.getState?.();
+      const analytics = state?.engine?.backgroundState?.AnalyticsController ?? {};
+      const consent = {
+        optedIn: Boolean(analytics.optedIn),
+        dataCollectionForMarketing: Boolean(state?.security?.dataCollectionForMarketing),
+        analyticsId: analytics.analyticsId ? 'set' : null
+      };
+      if (
+        consent.optedIn === ${JSON.stringify(participate)} &&
+        consent.dataCollectionForMarketing === ${JSON.stringify(marketing)} &&
+        (!${JSON.stringify(participate)} || consent.analyticsId === 'set')
+      ) return consent;
+      await delay(100);
+    }
+    throw new Error('Timed out reading back Mobile analytics consent.');
+  })()`;
+}
+
+runAdapter(async (input) => {
+  const { participate, marketing, timeoutMs } = consentParams(input.node);
+
+  const navigation = await navigate(input, 'SecuritySettings');
+  await evalAsync(input, toggleExpression(SWITCH_IDS.participate, participate, timeoutMs));
+  await evalAsync(input, toggleExpression(SWITCH_IDS.marketing, marketing, timeoutMs));
+  const consent = await evalAsync(
+    input,
+    stateExpression(participate, marketing, timeoutMs),
+  );
+
+  return {
+    action: input.action,
+    consent,
+    navigation,
+    proofPath: 'mobile-settings-consent',
+  };
+});

package/library/actions/shared/analytics/_adapter.mjs

@@ -0,0 +1,24 @@
+// Minimal adapter IO for the shared analytics actions.
+//
+// Mirrors the live-adapter contract in src/live-adapter-contract.ts. Neither
+// existing runAdapter fits: extension's lives under actions/extension/platform
+// and core's carries PerpsController teardown and expect_error handling. A
+// `shared/` action importing either would couple every platform to one of them,
+// so this is a deliberate 20-line duplicate of the contract itself.
+
+import { readFile, writeFile } from 'node:fs/promises';
+
+export async function runAdapter(callback) {
+  const inputPath = process.argv[2] || process.env.METAMASK_RECIPE_ADAPTER_INPUT;
+  if (!inputPath) throw new Error('Missing live adapter input path.');
+  const input = JSON.parse(await readFile(inputPath, 'utf8'));
+  try {
+    const output = await callback(input);
+    await writeFile(input.outputPath, `${JSON.stringify(output, null, 2)}\n`);
+  } catch (error) {
+    // No output file on failure — that is how the runner distinguishes a failed
+    // assertion from a passing one.
+    process.exitCode = 1;
+    process.stderr.write(`[shared/analytics] ${input.action} failed: ${error?.stack ?? error?.message ?? String(error)}\n`);
+  }
+}

package/library/actions/shared/analytics/assert_events.mjs

@@ -0,0 +1,168 @@
+import { runAdapter } from './_adapter.mjs';
+import { readCollected } from './collector.mjs';
+
+const DEFAULT_TIMEOUT_MS = 15000;
+// Why a settle window exists at all: a duplicate emit arrives *after* the
+// expected one. If this returned the instant a count reached its target it
+// would pass on the first of two events and never see the second — which is
+// precisely the defect class this action was built to catch. So: wait until
+// satisfiable, then keep waiting, then judge.
+const DEFAULT_SETTLE_MS = 1500;
+
+function nonNegativeNumber(value, name, fallback) {
+  if (value === undefined) return fallback;
+  if (value === '') throw new Error(`${name} must not be blank.`);
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${name} must be a non-negative number, got ${JSON.stringify(value)}.`);
+  }
+  return parsed;
+}
+
+function nonNegativeInteger(value, name, fallback) {
+  const parsed = nonNegativeNumber(value, name, fallback);
+  if (!Number.isInteger(parsed)) {
+    throw new Error(`${name} must be an integer, got ${JSON.stringify(value)}.`);
+  }
+  return parsed;
+}
+
+function matchesProperties(actual, expected) {
+  return Object.entries(expected).every(([key, want]) => {
+    const got = actual?.[key];
+    if (want !== null && typeof want === 'object') {
+      return JSON.stringify(got) === JSON.stringify(want);
+    }
+    // Segment serialises numbers inconsistently across clients.
+    if (typeof want === 'number' && typeof got === 'string' && got.trim() !== '') {
+      return Number(got) === want;
+    }
+    if (typeof got === 'number' && typeof want === 'string' && want.trim() !== '') {
+      return got === Number(want);
+    }
+    return Object.is(got, want);
+  });
+}
+
+function selectFor(expectation, events) {
+  return events.filter(
+    (entry) =>
+      entry.event === expectation.event &&
+      (!expectation.properties || matchesProperties(entry.properties, expectation.properties)),
+  );
+}
+
+function expectationsFrom(input) {
+  const raw = input.node?.expect;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new Error('metamask.analytics.assert_events requires a non-empty expect array.');
+  }
+  return raw.map((entry) => {
+    if (typeof entry?.event !== 'string' || entry.event.length === 0) {
+      throw new Error('Each expect entry requires a non-empty event name.');
+    }
+    const hasCount = entry.count !== undefined;
+    const hasBounds = entry.min !== undefined || entry.max !== undefined;
+    if (hasCount && hasBounds) {
+      throw new Error(`expect entry for "${entry.event}" sets both count and min/max; pick one.`);
+    }
+    const expectation = {
+      event: entry.event,
+      properties: entry.properties ?? null,
+      count: hasCount ? nonNegativeInteger(entry.count, `count for "${entry.event}"`) : undefined,
+      min: entry.min !== undefined
+        ? nonNegativeInteger(entry.min, `min for "${entry.event}"`)
+        : hasCount
+          ? nonNegativeInteger(entry.count, `count for "${entry.event}"`)
+          : 1,
+      max: entry.max !== undefined
+        ? nonNegativeInteger(entry.max, `max for "${entry.event}"`)
+        : hasCount
+          ? nonNegativeInteger(entry.count, `count for "${entry.event}"`)
+          : undefined,
+    };
+    if (expectation.max !== undefined && expectation.min > expectation.max) {
+      throw new Error(
+        `expect entry for "${entry.event}" has min ${expectation.min} greater than max ${expectation.max}.`,
+      );
+    }
+    return expectation;
+  });
+}
+
+function describe(expectation) {
+  const bound =
+    expectation.count !== undefined
+      ? `exactly ${expectation.count}`
+      : `min ${expectation.min}${expectation.max === undefined ? '' : `, max ${expectation.max}`}`;
+  const props = expectation.properties ? ` matching ${JSON.stringify(expectation.properties)}` : '';
+  return `"${expectation.event}"${props} (${bound})`;
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+runAdapter(async (input) => {
+  const since = nonNegativeNumber(input.node?.since, 'since', 0);
+  const timeoutMs = nonNegativeNumber(input.node?.timeout_ms, 'timeout_ms', DEFAULT_TIMEOUT_MS);
+  const settleMs = nonNegativeNumber(input.node?.settle_ms, 'settle_ms', DEFAULT_SETTLE_MS);
+  const exact = Boolean(input.node?.exact);
+  const expectations = expectationsFrom(input);
+
+  // Phase 1 — wait until every lower bound is reachable, or time out. Timing out
+  // is not itself a failure; the strict judgement below produces the message.
+  const deadline = Date.now() + timeoutMs;
+  let events = [];
+  for (;;) {
+    events = await readCollected(input, { since });
+    const allMet = expectations.every((e) => selectFor(e, events).length >= e.min);
+    if (allMet || Date.now() >= deadline) break;
+    await sleep(250);
+  }
+
+  // Phase 2 — settle, so a late duplicate lands before we judge.
+  await sleep(settleMs);
+  events = await readCollected(input, { since });
+
+  const failures = [];
+  const observed = [];
+  for (const expectation of expectations) {
+    const matched = selectFor(expectation, events);
+    observed.push({ event: expectation.event, matched: matched.length });
+    if (expectation.count !== undefined && matched.length !== expectation.count) {
+      failures.push(`expected ${describe(expectation)}, got ${matched.length}`);
+      continue;
+    }
+    if (matched.length < expectation.min) {
+      failures.push(`expected ${describe(expectation)}, got ${matched.length}`);
+      continue;
+    }
+    if (expectation.max !== undefined && matched.length > expectation.max) {
+      failures.push(`expected ${describe(expectation)}, got ${matched.length}`);
+    }
+  }
+
+  if (exact) {
+    const allowed = new Set(expectations.map((e) => e.event));
+    const unexpected = [...new Set(events.map((e) => e.event).filter((name) => name && !allowed.has(name)))];
+    if (unexpected.length) {
+      failures.push(`exact mode: unexpected event(s) ${unexpected.map((n) => `"${n}"`).join(', ')}`);
+    }
+  }
+
+  if (failures.length) {
+    const captured = events.map((e) => e.event).filter(Boolean);
+    throw new Error(
+      [
+        `metamask.analytics.assert_events failed:`,
+        ...failures.map((line) => `  - ${line}`),
+        `  captured since ${since}: ${captured.length ? captured.join(', ') : '(none)'}`,
+        // A missing-property failure here is most often a consent problem, not a
+        // client bug: platform-adapter strips utm_* unless BOTH
+        // participateInMetaMetrics and dataCollectionForMarketing are true.
+        `  if utm_* / marketing properties are missing, check MetaMetrics consent before suspecting the client.`,
+      ].join('\n'),
+    );
+  }
+
+  return { action: input.action, since, exact, observed, capturedCount: events.length };
+});