dappress 0.3.3 → 0.5.0

package/src/profile.js

@@ -1,125 +0,0 @@
-// Onboard the wallet once, in a browser of our own, and keep the resulting
-// profile. Each Cypress run then starts from a copy of it, with the wallet
-// imported but nothing else: no connected site, no added network.
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const puppeteer = require('puppeteer-core');
-const metamask = require('./metamask');
-const { findExtensionId, getHomePage } = require('./metamask-pages');
-
-// One build at a time: Cypress calls before:browser:launch again when the
-// browser is slow to connect, and two builds on one profile would collide
-const builds = new Map();
-
-/** The cached profile for these options, built on first use. */
-function prepareProfile({ browserPath, extensionDir, options }) {
-  const key = crypto.createHash('sha256').update([options.metamaskVersion, options.seedPhrase, options.password, options.backupAndSync].join('|')).digest('hex').slice(0, 16);
-  if (!builds.has(key)) builds.set(key, buildProfile(path.join(options.cacheDir, 'profiles', key), { browserPath, extensionDir, options }));
-  return builds.get(key);
-}
-
-async function buildProfile(dir, { browserPath, extensionDir, options }) {
-  if (fs.existsSync(path.join(dir, 'ready'))) return dir;
-
-  console.log('[dappress] Importing the wallet once, into a cached profile…');
-  await fs.promises.rm(dir, { recursive: true, force: true });
-  const launch = () =>
-    puppeteer.launch({
-      executablePath: browserPath,
-      headless: false,
-      userDataDir: dir,
-      args: [
-        `--load-extension=${extensionDir}`,
-        `--disable-extensions-except=${extensionDir}`,
-        '--no-first-run',
-        // No sandbox on Linux: Ubuntu 23.10+ (GitHub's ubuntu-latest) blocks the
-        // user namespaces it needs, and this browser only imports a test wallet
-        ...(process.platform === 'linux' ? ['--no-sandbox'] : []),
-      ],
-    });
-
-  await withMetaMask(launch, (home) => metamask.onboard(home, options));
-  // Reopen the profile: the wallet must now be there, locked, with no onboarding left
-  await withMetaMask(launch, async (home) => {
-    const state = await metamask.walletState(home);
-    if (state !== 'locked') throw new Error(`[dappress] The cached profile did not keep the wallet: MetaMask is ${state} at ${home.url()}`);
-    await metamask.unlock(home, options);
-  });
-  fs.writeFileSync(path.join(dir, 'ready'), '');
-  return dir;
-}
-
-// MetaMask persists its state a moment after the last screen; leave it that moment before closing
-async function withMetaMask(launch, action) {
-  const browser = await launch();
-  try {
-    const home = await getHomePage(browser, await findExtensionId(browser));
-    await keepInFront(browser, home);
-    await action(home);
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-  } finally {
-    await browser.close();
-  }
-}
-
-// Chrome stops rendering a tab that isn't the active one, and Puppeteer waits
-// on rendering to find an element or to click it: a hidden tab never answers.
-// So the home page is made the active tab, and again whenever MetaMask opens
-// a tab of its own, as it does for its onboarding right after the install.
-async function keepInFront(browser, home) {
-  const toFront = () => home.bringToFront().catch(() => {});
-  await toFront();
-  browser.on('targetcreated', (target) => {
-    if (target.type() !== 'page') return;
-    toFront();
-    setTimeout(toFront, 500);
-  });
-}
-
-// Where Cypress is about to create the browser profile:
-// <app data>/Cypress/cy/<env>/browsers/<name>-<channel>/run-<pid of the Cypress process>,
-// or .../interactive in open mode. The pid is our parent's: Cypress runs
-// setupNodeEvents in a child process. Returns null when it can't be found.
-function cypressProfileDir(browser, isTextTerminal) {
-  const appData = [
-    path.join(os.homedir(), 'Library', 'Application Support'),
-    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
-    process.env.APPDATA,
-  ].filter(Boolean);
-  const cypressData = appData.map((dir) => path.join(dir, 'Cypress', 'cy')).find((dir) => fs.existsSync(dir));
-  if (!cypressData) return null;
-  const env = ['production', 'development'].find((name) => fs.existsSync(path.join(cypressData, name)));
-  if (!env) return null;
-  return path.join(cypressData, env, 'browsers', `${browser.name}-${browser.channel}`, isTextTerminal ? `run-${process.ppid}` : 'interactive');
-}
-
-/**
- * Copy MetaMask's data from the cached profile into the profile Cypress is
- * about to launch. Returns false when that profile can't be located; the
- * wallet is then imported during the run instead.
- */
-async function installProfile(profileDir, browser, isTextTerminal) {
-  const userDataDir = cypressProfileDir(browser, isTextTerminal);
-  if (!userDataDir) {
-    console.warn('[dappress] Could not locate the Cypress browser profile; importing the wallet in this run instead');
-    return false;
-  }
-  for (const entry of metamaskData(profileDir)) {
-    await fs.promises.cp(path.join(profileDir, entry), path.join(userDataDir, entry), { recursive: true });
-  }
-  return true;
-}
-
-// Where Chrome keeps an extension's storage: chrome.storage.local and IndexedDB
-function metamaskData(profileDir) {
-  const base = path.join(profileDir, 'Default');
-  const entries = ['Local Extension Settings', 'IndexedDB'];
-  return entries
-    .filter((entry) => fs.existsSync(path.join(base, entry)))
-    .flatMap((entry) => fs.readdirSync(path.join(base, entry)).map((name) => path.join('Default', entry, name)));
-}
-
-module.exports = { prepareProfile, installProfile };

package/src/support.js

@@ -1,90 +0,0 @@
-// Cypress commands. Import this file from your support file:
-//
-//   import 'dappress/support';
-//
-// Each command asks the Node side (src/actions.js) to drive MetaMask through
-// a Cypress task, then yields back to the test.
-
-const options = Cypress.expose('dappress') || {};
-
-// `shown` is what the command log displays for the argument, if anything
-function metamask(action, argument = null, shown = '') {
-  Cypress.log({ name: 'metamask', message: `${action} ${shown}`.trim() });
-  return cy.task(`dappress:${action}`, argument, { log: false });
-}
-
-function provider(method, params) {
-  return cy.window({ log: false }).then((win) => win.ethereum.request({ method, params }));
-}
-
-Cypress.Commands.add('setupMetaMask', () => metamask('setupWallet'));
-Cypress.Commands.add('rejectConnection', () => metamask('rejectConnection'));
-Cypress.Commands.add('approveNewNetwork', () => metamask('approveNewNetwork'));
-Cypress.Commands.add('rejectNewNetwork', () => metamask('rejectNewNetwork'));
-Cypress.Commands.add('approveSwitchNetwork', () => metamask('approveSwitchNetwork'));
-Cypress.Commands.add('rejectSwitchNetwork', () => metamask('rejectSwitchNetwork'));
-Cypress.Commands.add('confirmSignature', () => metamask('confirmSignature'));
-Cypress.Commands.add('rejectSignature', () => metamask('rejectSignature'));
-Cypress.Commands.add('confirmTransaction', () => metamask('confirmTransaction'));
-Cypress.Commands.add('rejectTransaction', () => metamask('rejectTransaction'));
-Cypress.Commands.add('approveAddToken', () => metamask('approveAddToken'));
-Cypress.Commands.add('rejectAddToken', () => metamask('rejectAddToken'));
-
-// The wallet's own accounts. A new or imported account becomes the selected
-// one; the dapp sees it once it connects with it.
-Cypress.Commands.add('addAccount', () => metamask('addAccount'));
-Cypress.Commands.add('switchAccount', (name) => metamask('switchAccount', name, name));
-// The private key is kept out of the command log
-Cypress.Commands.add('importAccount', (privateKey) => metamask('importAccount', privateKey));
-
-// Connect, then move the dapp onto the network from the wallet setup, if there is one
-Cypress.Commands.add('connectToDapp', () => {
-  metamask('connectToDapp');
-  if (options.network) cy.useNetwork(options.network);
-});
-
-// Move the dapp onto `network` (a wallet_addEthereumChain parameter), adding
-// it to MetaMask if needed. A switch to a network the dapp is already allowed
-// on settles at once; anything else makes MetaMask ask, and we approve.
-Cypress.Commands.add('useNetwork', (network = options.network) => {
-  if (!network) throw new Error('[dappress] cy.useNetwork() needs a network, or one in cypress/wallet.setup.js');
-  Cypress.log({ name: 'metamask', message: `useNetwork ${network.chainName || network.chainId}` });
-  cy.window({ log: false }).then((win) => {
-    win.dappressNetwork = { settled: false };
-    win.dappressNetwork.request = win.ethereum
-      .request({ method: 'wallet_addEthereumChain', params: [network] })
-      .then((result) => ({ result }), (error) => ({ error }))
-      .finally(() => (win.dappressNetwork.settled = true));
-  });
-  cy.wait(1500, { log: false });
-  cy.window({ log: false }).then((win) => {
-    if (!win.dappressNetwork.settled) metamask('approveNetworkChange');
-  });
-  cy.window({ log: false }).then({ timeout: 60000 }, (win) => win.dappressNetwork.request).then(({ error }) => {
-    if (error) throw new Error(`[dappress] MetaMask refused the network: ${error.message}`);
-  });
-  waitForChainId(network.chainId);
-});
-
-// The address the dapp sees, asked to the injected provider rather than to the
-// MetaMask UI, so it keeps working across MetaMask versions.
-Cypress.Commands.add('getAccountAddress', () => {
-  Cypress.log({ name: 'metamask', message: 'getAccountAddress' });
-  return provider('eth_accounts').then(([address]) => address);
-});
-
-// MetaMask announces the new chain to the dapp shortly after the switch
-function waitForChainId(chainId, attempts = 20) {
-  return provider('eth_chainId').then((current) => {
-    if (current === chainId) return current;
-    if (attempts === 0) throw new Error(`[dappress] The dapp is on chain ${current}, not ${chainId}`);
-    return cy.wait(500, { log: false }).then(() => waitForChainId(chainId, attempts - 1));
-  });
-}
-
-// Onboard or unlock the wallet once per spec, before the dapp needs it.
-if (options.autoSetup !== false) {
-  before(() => {
-    cy.setupMetaMask();
-  });
-}

package/types/index.d.ts

@@ -1,55 +0,0 @@
-/// <reference types="cypress" />
-
-/** A network, as passed to MetaMask's wallet_addEthereumChain. */
-export interface Network {
-  chainId: string;
-  chainName: string;
-  rpcUrls: string[];
-  nativeCurrency: { name: string; symbol: string; decimals: number };
-  blockExplorerUrls?: string[];
-  iconUrls?: string[];
-}
-
-/** What cypress/wallet.setup.ts exports. */
-export interface WalletSetup {
-  /**
-   * The wallet to import. Without one, Dappress makes a new wallet for each run.
-   * Prefer DAPPRESS_SEED_PHRASE in cypress.env.json or the environment: this file is usually committed.
-   */
-  seedPhrase?: string;
-  /** The network the dapp is moved onto by cy.connectToDapp(). */
-  network?: Network;
-}
-
-export interface DappressOptions extends WalletSetup {
-  /** Password of the throwaway browser profile's wallet. Default: Tester@1234. */
-  password?: string;
-  /** MetaMask release to load, downloaded from GitHub on first run. */
-  metamaskVersion?: string;
-  /**
-   * Keep MetaMask's backup and sync on. It saves the accounts and contacts of a
-   * seed phrase and restores them on other installs. Default: false.
-   */
-  backupAndSync?: boolean;
-  /** Run cy.setupMetaMask() before the first test of each spec. Default: true. */
-  autoSetup?: boolean;
-  /** Import the wallet once and reuse the profile across runs. Keeps the vault under cacheDir. Headed runs only. Default: false. */
-  cache?: boolean;
-  /** Time allowed for MetaMask to display a request, in ms. Default: 20000. */
-  timeout?: number;
-  /** Where MetaMask builds are cached. Default: ~/.cache/dappress. */
-  cacheDir?: string;
-}
-
-/**
- * Wire Dappress into a Cypress project, from setupNodeEvents:
- *
- *   setupNodeEvents(on, config) {
- *     return configureDappress(on, config);
- *   }
- */
-export function configureDappress(
-  on: Cypress.PluginEvents,
-  config: Cypress.PluginConfigOptions,
-  options?: DappressOptions,
-): Cypress.PluginConfigOptions;

package/types/support.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="cypress" />
-
-import type { Network } from './index';
-
-export type WalletState = 'onboarding' | 'locked' | 'unlocked';
-
-declare global {
-  namespace Cypress {
-    interface Chainable {
-      /** Imports or unlocks the wallet. Runs by itself before each spec unless autoSetup is false. */
-      setupMetaMask(): Chainable<WalletState>;
-      /** Accepts the connection request, then moves the dapp onto the wallet setup's network if there is one. */
-      connectToDapp(): Chainable<void>;
-      rejectConnection(): Chainable<void>;
-      /** Answers a signature request (personal_sign, eth_signTypedData_*). */
-      confirmSignature(): Chainable<void>;
-      rejectSignature(): Chainable<void>;
-      /** Answers a transaction, including ERC-20 approvals. */
-      confirmTransaction(): Chainable<void>;
-      rejectTransaction(): Chainable<void>;
-      /** Answers wallet_addEthereumChain. */
-      approveNewNetwork(): Chainable<void>;
-      rejectNewNetwork(): Chainable<void>;
-      /** Answers the permission asked before switching to a network the dapp isn't allowed on yet. */
-      approveSwitchNetwork(): Chainable<void>;
-      rejectSwitchNetwork(): Chainable<void>;
-      /** Answers wallet_watchAsset ("Add suggested tokens"). */
-      approveAddToken(): Chainable<void>;
-      rejectAddToken(): Chainable<void>;
-      /** Adds an account to the wallet and selects it. Yields its name, "Account N". */
-      addAccount(): Chainable<string>;
-      /** Selects an account of the wallet by its name. */
-      switchAccount(name: string): Chainable<void>;
-      /** Imports an account from its private key and selects it. Yields its name. */
-      importAccount(privateKey: string): Chainable<string>;
-      /** Moves the dapp onto a network, adding it to MetaMask if needed. Defaults to the wallet setup's network. Yields the chain id. */
-      useNetwork(network?: Network): Chainable<string>;
-      /** The address the dapp is connected with. */
-      getAccountAddress(): Chainable<string>;
-    }
-  }
-}