@deeeed/metamask-harness 0.38.1 → 0.40.0

package/library/actions/mobile/assets/set_token_visibility.mjs

@@ -0,0 +1,302 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+function descendants(snapshot, root) {
+  const byParent = new Map();
+  for (const node of snapshot.nodes) {
+    const children = byParent.get(node.parentIndex) ?? [];
+    children.push(node);
+    byParent.set(node.parentIndex, children);
+  }
+  const found = [];
+  const queue = [...(byParent.get(root.index) ?? [])];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    found.push(node);
+    queue.push(...(byParent.get(node.index) ?? []));
+  }
+  return found;
+}
+
+function searchedToken(snapshot, query) {
+  const normalized = query.toUpperCase();
+  const rows = snapshot.nodes.filter((node) => node.identifier === 'searched-token-result');
+  for (const row of rows) {
+    const children = descendants(snapshot, row);
+    const label = children.map(nativeLabel).find((value) => {
+      const parts = value.split(',').map((part) => part.trim().toUpperCase());
+      return parts.includes(normalized);
+    });
+    if (label) {
+      return {
+        row,
+        label,
+        imported: row.enabled === false && children.some((node) => /CheckBox$/u.test(String(node.type))),
+      };
+    }
+  }
+  const imported = rows.find((row) =>
+    row.enabled === false && descendants(snapshot, row).some((node) => /CheckBox$/u.test(String(node.type)))
+  );
+  return imported ? { row: imported, label: query, imported: true } : null;
+}
+
+function visibleNode(snapshot, identifier) {
+  return snapshot.nodes.find((node) =>
+    node.identifier === identifier && node.visibleToUser !== false && node.hittable !== false
+  );
+}
+
+async function waitForSnapshot(session, timeoutMs, predicate, message) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const snapshot = await session.snapshot();
+    const value = predicate(snapshot);
+    if (value) return { snapshot, value };
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error(message);
+}
+
+async function openImport(session, timeoutMs) {
+  let snapshot = await session.snapshot();
+  if (visibleNode(snapshot, 'input-search-asset')) return;
+  if (!nativeNode(snapshot, 'import-token-button')) {
+    await session.execute('ui.press', {
+      test_id: 'homepage-section-title-tokens',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => nativeNode(current, 'import-token-button'),
+      'The Mobile token list did not expose Import tokens.',
+    )).snapshot;
+  }
+  if (!visibleNode(snapshot, 'input-search-asset') && !nativeNode(snapshot, 'input-token-address')) {
+    await session.execute('ui.press', {
+      test_id: 'import-token-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => visibleNode(current, 'input-search-asset') ??
+        nativeNode(current, 'input-token-address') ??
+        current.nodes.find((node) => nativeLabel(node) === 'Search' && node.hittable === true),
+      'The Mobile token import tabs did not become visible.',
+    )).snapshot;
+  }
+  if (!visibleNode(snapshot, 'input-search-asset')) {
+    await session.execute('ui.press', { text: 'Search', timeout_ms: timeoutMs, settle: false });
+  }
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (current) => visibleNode(current, 'input-search-asset'),
+    'The Mobile token search did not open.',
+  );
+}
+
+async function searchToken(session, query, timeoutMs) {
+  const snapshot = await session.snapshot();
+  if (nativeNode(snapshot, 'clear-search-bar')) {
+    await session.execute('ui.press', {
+      test_id: 'clear-search-bar',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+  }
+  await session.execute('ui.press', {
+    test_id: 'input-search-asset',
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+  await session.client.interactions.type({
+    ...session.selection,
+    text: query,
+    delayMs: 50,
+    responseLevel: 'digest',
+  });
+  return (await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => searchedToken(snapshot, query),
+    `Mobile token search returned no exact result for ${query}.`,
+  )).value;
+}
+
+async function enableToken(session, query, requireUnchanged, requireChange, timeoutMs) {
+  await openImport(session, timeoutMs);
+  let match = await searchToken(session, query, timeoutMs);
+  const alreadyImported = match.imported;
+  if (requireUnchanged && !match.imported) {
+    throw new Error(`${query} token import did not persist.`);
+  }
+  if (requireChange && match.imported) {
+    throw new Error(`${query} was already imported before the requested visibility change.`);
+  }
+  if (!match.imported) {
+    await session.execute('ui.press', { text: match.label, timeout_ms: timeoutMs, settle: false });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'token-import-next-button')?.enabled === true,
+      `Selecting ${query} did not enable the token import action.`,
+    );
+    await session.execute('ui.press', {
+      test_id: 'token-import-next-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'bottomsheetfooter-button-subsequent'),
+      `The ${query} import confirmation did not open.`,
+    );
+    await session.execute('ui.press', {
+      test_id: 'bottomsheetfooter-button-subsequent',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'import-token-button'),
+      `The ${query} import did not return to the token list.`,
+    );
+    await openImport(session, timeoutMs);
+    match = await searchToken(session, query, timeoutMs);
+    if (!match.imported) throw new Error(`${query} did not remain imported after confirmation.`);
+  }
+  await session.execute('ui.press', { test_id: 'button-icon', timeout_ms: timeoutMs, settle: false });
+  return {
+    changed: !alreadyImported,
+    imported: true,
+    proofPath: 'native-accessibility-token-search-import-state',
+  };
+}
+
+async function findVisibleAsset(session, query, timeoutMs) {
+  let snapshot = await session.snapshot();
+  if (!nativeNode(snapshot, 'token-list')) {
+    await session.execute('ui.press', {
+      test_id: 'homepage-section-title-tokens',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => nativeNode(current, 'token-list'),
+      'The Mobile token list did not open.',
+    )).snapshot;
+  }
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    if (nativeNode(snapshot, `asset-${query.toUpperCase()}`)) return true;
+    await session.execute('ui.scroll', { direction: 'down', timeout_ms: timeoutMs, settle: false });
+    snapshot = await session.snapshot();
+  }
+  return false;
+}
+
+async function disableToken(session, query, requireUnchanged, requireChange, timeoutMs) {
+  const present = await findVisibleAsset(session, query, timeoutMs);
+  if (!present) {
+    if (requireChange) throw new Error(`${query} was not visible before the requested visibility change.`);
+    return {
+      changed: false,
+      imported: false,
+      proofPath: 'native-accessibility-token-row-absent',
+    };
+  }
+  if (requireUnchanged) throw new Error(`${query} remained visible instead of hidden.`);
+  await session.execute('ui.press', {
+    test_id: `asset-${query.toUpperCase()}`,
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => nativeNode(snapshot, 'token-more-button'),
+    `${query} token details did not expose More.`,
+  );
+  await session.execute('ui.press', { test_id: 'token-more-button', timeout_ms: timeoutMs, settle: false });
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => nativeNode(snapshot, 'more-actions-remove-token'),
+    `${query} is not removable from the visible Mobile token details.`,
+  );
+  await session.execute('ui.press', {
+    test_id: 'more-actions-remove-token',
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+  const confirmation = await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => nativeNode(snapshot, 'remove-token-bottom-sheet-remove-button') ??
+      nativeNode(snapshot, 'asset-hide-confirmation-button') ??
+      snapshot.nodes.find((node) =>
+        node.visibleToUser !== false &&
+        /Button$/u.test(String(node.type)) &&
+        nativeLabel(node) === 'Confirm'
+      ),
+    `${query} token removal did not request confirmation.`,
+  );
+  await session.execute('ui.press', confirmation.value.identifier
+    ? { test_id: confirmation.value.identifier, timeout_ms: timeoutMs, settle: false }
+    : { text: 'Confirm', timeout_ms: timeoutMs, settle: false });
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => nativeNode(snapshot, `asset-${query.toUpperCase()}`) ? null : true,
+    `${query} remained visible after removal.`,
+  );
+  return {
+    changed: true,
+    imported: false,
+    proofPath: 'native-accessibility-token-details-removal',
+  };
+}
+
+runAdapter(async (input) => {
+  const query = String(input.node?.query ?? '').trim();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 45_000);
+  const requested = input.node?.visible;
+  const requireUnchanged = input.node?.require_unchanged === true;
+  const requireChange = input.node?.require_change === true;
+  if (!query || query.length > 50) {
+    throw new Error('metamask.assets.set_token_visibility requires query with 1-50 characters.');
+  }
+  if (typeof requested !== 'boolean') {
+    throw new Error('metamask.assets.set_token_visibility requires visible=true or visible=false.');
+  }
+  const session = createNativeSession(input, 'Assets', `token-visibility-${process.pid}`);
+  try {
+    await session.open();
+    const result = requested
+      ? await enableToken(session, query, requireUnchanged, requireChange, timeoutMs)
+      : await disableToken(session, query, requireUnchanged, requireChange, timeoutMs);
+    return {
+      action: input.action,
+      query,
+      requested,
+      requireUnchanged,
+      requireChange,
+      ...result,
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/assets/verify_sorting.mjs

@@ -0,0 +1,104 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+} from '../platform/native-session.mjs';
+
+function assetRows(snapshot) {
+  const byIndex = new Map(snapshot.nodes.map((node) => [node.index, node]));
+  const belongsToTokenList = (node) => {
+    let current = node;
+    for (let depth = 0; depth < 40 && current; depth += 1) {
+      if (String(current.identifier ?? '') === 'token-list') return true;
+      current = byIndex.get(current.parentIndex);
+    }
+    return false;
+  };
+  return snapshot.nodes
+    .filter((node) => belongsToTokenList(node)
+      && /^asset-[A-Za-z0-9._:-]+$/u.test(String(node.identifier ?? '')))
+    .map((node) => {
+      const label = nativeLabel(node);
+      const fiat = label.match(/[$€£¥]\s?([0-9][0-9,]*(?:\.\d{2})?)/u)?.[1];
+      return {
+        testId: String(node.identifier),
+        name: label.split(',')[0]?.trim() || String(node.identifier).slice('asset-'.length),
+        fiat: fiat ? Number(fiat.replaceAll(',', '')) : null,
+      };
+    });
+}
+
+function isAlphabetical(rows) {
+  const names = rows.map((row) => row.name);
+  const expected = [...names].sort((left, right) => left.localeCompare(right, 'en', { sensitivity: 'base' }));
+  return names.length >= 2 && names.every((name, index) => name === expected[index]);
+}
+
+function isDeclining(rows) {
+  const values = rows.map((row) => row.fiat).filter((value) => value !== null);
+  return values.length >= 2 && values.every((value, index) => index === 0 || values[index - 1] >= value);
+}
+
+async function choose(session, option, timeoutMs) {
+  await session.execute('ui.press', { test_id: 'token-sort-button', timeout_ms: timeoutMs, settle: false });
+  await session.execute('ui.press', { test_id: option, timeout_ms: timeoutMs, settle: false });
+  const deadline = Date.now() + timeoutMs;
+  let rows = [];
+  while (Date.now() <= deadline) {
+    const snapshot = await session.snapshot();
+    rows = assetRows(snapshot);
+    if (rows.length >= 2 && !sessionNode(snapshot, option)) return rows;
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error(`Asset sort ${option} did not return to a visible token list: ${JSON.stringify(rows)}.`);
+}
+
+async function revealTokenList(session, timeoutMs) {
+  if (sessionNode(await session.snapshot(), 'token-sort-button')) return;
+  await session.execute('ui.press', {
+    test_id: 'homepage-section-title-tokens',
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    if (sessionNode(await session.snapshot(), 'token-sort-button')) return;
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error('Assets token-list sort control did not become visible after opening Tokens.');
+}
+
+function sessionNode(snapshot, identifier) {
+  return snapshot.nodes.find((node) => String(node.identifier ?? '') === identifier);
+}
+
+runAdapter(async (input) => {
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  const session = createNativeSession(input, 'Assets', `sort-${process.pid}`);
+  try {
+    await session.open();
+    await revealTokenList(session, timeoutMs);
+    const alphabetical = await choose(session, 'sort-alphabetical', timeoutMs);
+    const declining = await choose(session, 'sort-declining-balance', timeoutMs);
+    const failures = [];
+    if (!isAlphabetical(alphabetical)) {
+      failures.push(`A-Z order was ${alphabetical.map((row) => row.name).join(', ')}`);
+    }
+    if (!isDeclining(declining)) {
+      failures.push(`declining fiat order was ${declining.map((row) => row.fiat).join(', ')}`);
+    }
+    if (failures.length > 0) {
+      throw new Error(`Asset token sorting failed: ${failures.join('; ')}.`);
+    }
+    return {
+      action: input.action,
+      alphabetical: alphabetical.map((row) => row.name),
+      decliningFiat: declining.map((row) => row.fiat),
+      restoredSort: 'declining-balance',
+      proofPath: 'native-accessibility-token-sorting',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/networks/add_custom.mjs

@@ -0,0 +1,125 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeNode,
+} from '../platform/native-session.mjs';
+import {
+  clearNetworkSearch,
+  findNetwork,
+  IDS,
+  openNetworkManager,
+  waitForSnapshot,
+} from './network-management.mjs';
+
+const FIELDS = {
+  network: 'network-details-view-name-input',
+  rpcUrl: 'network-details-view-rpc-url-input',
+  rpcName: 'network-details-view-rpc-name-input',
+  chainId: 'network-details-view-chain-id-input',
+  symbol: 'network-details-view-symbol-input',
+  explorerUrl: 'network-details-view-block-explorer-input',
+};
+
+async function fill(session, testId, value, timeoutMs) {
+  await session.execute('ui.set_input', {
+    test_id: testId,
+    value,
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+}
+
+runAdapter(async (input) => {
+  const network = String(input.node?.network ?? '').trim();
+  const rpcUrl = String(input.node?.rpc_url ?? '').trim();
+  const chainId = Number(input.node?.chain_id);
+  const symbol = String(input.node?.symbol ?? '').trim().toUpperCase();
+  const explorerUrl = String(input.node?.explorer_url ?? '').trim();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 60_000);
+  if (!network || !/^https:\/\//u.test(rpcUrl) || !Number.isInteger(chainId) || chainId <= 0 || !symbol) {
+    throw new Error('metamask.networks.add_custom requires network, HTTPS rpc_url, positive chain_id, and symbol.');
+  }
+  if (explorerUrl && !/^https:\/\//u.test(explorerUrl)) {
+    throw new Error('metamask.networks.add_custom explorer_url must use HTTPS.');
+  }
+
+  const session = createNativeSession(input, 'Networks', `add-${process.pid}`);
+  try {
+    await session.open();
+    await openNetworkManager(session, timeoutMs);
+    let item = await findNetwork(session, network, chainId, timeoutMs);
+    if (item) {
+      return {
+        action: input.action,
+        network,
+        chainId,
+        symbol,
+        rpcUrl,
+        explorerUrl: explorerUrl || null,
+        added: false,
+        item,
+        proofPath: 'native-accessibility-network-settings',
+      };
+    }
+
+    await clearNetworkSearch(session, timeoutMs);
+    await session.execute('ui.key_press', { key: 'BACK', timeout_ms: timeoutMs, settle: false });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, IDS.add),
+      'Mobile Networks settings did not expose Add network after closing search.',
+    );
+    await session.execute('ui.press', { test_id: IDS.add, timeout_ms: timeoutMs, settle: false });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, IDS.details),
+      'The Mobile custom-network form did not open.',
+    );
+    await fill(session, FIELDS.network, network, timeoutMs);
+    await fill(session, FIELDS.rpcUrl, rpcUrl, timeoutMs);
+    await fill(session, FIELDS.rpcName, `${network} RPC`, timeoutMs);
+    await fill(session, FIELDS.chainId, String(chainId), timeoutMs);
+    await fill(session, FIELDS.symbol, symbol, timeoutMs);
+    if (explorerUrl) await fill(session, FIELDS.explorerUrl, explorerUrl, timeoutMs);
+    await session.execute('ui.key_press', { key: 'BACK', timeout_ms: timeoutMs, settle: false });
+
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => {
+        const button = nativeNode(snapshot, 'network-details-view-add-button');
+        return button?.enabled === true ? button : null;
+      },
+      'Custom-network Save did not become enabled after RPC validation.',
+    );
+    await session.execute('ui.press', {
+      test_id: 'network-details-view-add-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, IDS.manager),
+      'Mobile Networks settings did not reopen after custom-network save.',
+    );
+    item = await findNetwork(session, network, chainId, timeoutMs);
+    if (!item) throw new Error(`${network} (${chainId}) was absent after custom-network save.`);
+    return {
+      action: input.action,
+      network,
+      chainId,
+      symbol,
+      rpcUrl,
+      explorerUrl: explorerUrl || null,
+      added: true,
+      item,
+      proofPath: 'native-accessibility-network-settings',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/networks/network-management.mjs

@@ -0,0 +1,132 @@
+import { nativeLabel, nativeNode } from '../platform/native-session.mjs';
+
+const IDS = {
+  add: 'networks-settings-add-custom-network-button',
+  details: 'network-details-view-container',
+  hamburger: 'navbar-hamburger-menu-button',
+  menu: 'networks-menu-item',
+  manager: 'networks-settings-container',
+  search: 'networks-settings-search-input',
+  wallet: ['wallet-safe-area', 'homepage-container'],
+};
+
+export function networkItemId(chainId) {
+  return `networks-settings-network-item-0x${chainId.toString(16)}`;
+}
+
+export function visibleNode(snapshot, identifier) {
+  return snapshot.nodes.find((node) =>
+    node.identifier === identifier &&
+    node.visibleToUser !== false &&
+    node.hittable !== false
+  );
+}
+
+export async function waitForSnapshot(session, timeoutMs, predicate, message) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const snapshot = await session.snapshot();
+    const value = predicate(snapshot);
+    if (value) return { snapshot, value };
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error(message);
+}
+
+async function systemBack(session) {
+  await session.client.command.back({
+    ...session.selection,
+    mode: 'system',
+    responseLevel: 'digest',
+  });
+}
+
+export async function openNetworkManager(session, timeoutMs) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const snapshot = await session.snapshot();
+    if (visibleNode(snapshot, IDS.manager)) return snapshot;
+    if (visibleNode(snapshot, IDS.details)) {
+      await systemBack(session);
+      continue;
+    }
+    if (visibleNode(snapshot, IDS.menu)) {
+      await session.execute('ui.press', { test_id: IDS.menu, timeout_ms: timeoutMs, settle: false });
+      continue;
+    }
+    if (IDS.wallet.some((identifier) => nativeNode(snapshot, identifier))) {
+      await session.execute('ui.press', { test_id: IDS.hamburger, timeout_ms: timeoutMs, settle: false });
+      continue;
+    }
+    await systemBack(session);
+  }
+  return (await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => visibleNode(snapshot, IDS.manager),
+    'The Mobile Networks settings screen did not open.',
+  )).snapshot;
+}
+
+export async function findNetwork(session, network, chainId, timeoutMs) {
+  const itemId = networkItemId(chainId);
+  let snapshot = await session.snapshot();
+  let item = visibleNode(snapshot, itemId);
+  if (!item) {
+    await session.execute('ui.set_input', {
+      test_id: IDS.search,
+      value: network,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => visibleNode(current, itemId) ?? current.nodes.find((node) =>
+        nativeLabel(node).toLowerCase() === 'no networks found'
+      ),
+      `Mobile Networks search did not settle for ${network}.`,
+    )).snapshot;
+    item = visibleNode(snapshot, itemId);
+  }
+  if (!item) return null;
+  const label = nativeLabel(item);
+  if (label && !label.toLowerCase().includes(network.toLowerCase())) {
+    throw new Error(`${itemId} did not identify ${network}; observed ${JSON.stringify(label)}.`);
+  }
+  return { id: itemId, label: label || network };
+}
+
+export async function clearNetworkSearch(session, timeoutMs) {
+  const snapshot = await session.snapshot();
+  const search = nativeNode(snapshot, IDS.search);
+  const searchValue = nativeLabel(search);
+  if (!search || !searchValue || searchValue.toLowerCase() === 'search networks') return;
+  const clear = snapshot.nodes.find((node) =>
+    node.parentIndex === search.parentIndex &&
+    node.index > search.index &&
+    node.hittable === true &&
+    node.ref
+  );
+  if (!clear?.ref) {
+    throw new Error('Mobile Networks search did not expose a semantic clear control.');
+  }
+  await session.client.interactions.press({
+    ...session.selection,
+    ref: `@${clear.ref}`,
+    settle: true,
+    verify: true,
+    timeoutMs,
+    responseLevel: 'digest',
+  });
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (current) => {
+      const value = nativeLabel(nativeNode(current, IDS.search));
+      return !value || value.toLowerCase() === 'search networks' ? true : null;
+    },
+    'Mobile Networks search did not clear.',
+  );
+}
+
+export { IDS };