@metamask/snaps-jest 0.35.1-flask.1

package/dist/esm/internals/wait-for.js

@@ -0,0 +1,63 @@
+import { assert, createModuleLogger } from '@metamask/utils';
+import { waitFor as waitForPuppeteer } from 'pptr-testing-library';
+import { rootLogger } from './logger';
+const log = createModuleLogger(rootLogger, 'wait-for');
+/**
+ * Wait for a condition to be true. This is a wrapper around
+ * `pptr-testing-library`'s `waitFor` function, with the addition of a custom
+ * error message.
+ *
+ * @param fn - The condition to wait for.
+ * @param options - The options.
+ * @param options.timeout - The timeout in milliseconds.
+ * @param options.message - The error message to throw if the condition is not
+ * met.
+ * @returns A promise that resolves when the condition is met. The promise
+ * resolves to the return value of the condition function.
+ */ export async function waitFor(fn, { timeout = 3000, message } = {}) {
+    try {
+        let result;
+        await waitForPuppeteer(// eslint-disable-next-line @typescript-eslint/no-misused-promises
+        async ()=>{
+            // Puppeteer's `waitFor` function does not support returning a value
+            // from the condition function, so we need to use a variable outside
+            // the scope of the function.
+            result = await fn();
+        }, {
+            timeout
+        });
+        assert(result !== undefined);
+        return result;
+    } catch (error) {
+        if (message) {
+            throw new Error(message);
+        }
+        throw error;
+    }
+}
+/**
+ * Wait for a JSON-RPC response.
+ *
+ * @param page - The page to wait for the response on.
+ * @param type - The type of response to wait for.
+ * @returns The JSON-RPC response.
+ */ export async function waitForResponse(page, type) {
+    log('Waiting for response of type %s.', type);
+    return await page.evaluate(async (_type)=>{
+        return new Promise((resolve)=>{
+            window.__SIMULATOR_API__.dispatch({
+                type: `${_type}/clearResponse`
+            });
+            const unsubscribe = window.__SIMULATOR_API__.subscribe(()=>{
+                const state = window.__SIMULATOR_API__.getState();
+                const { pending, response } = state[_type];
+                if (!pending && response) {
+                    unsubscribe();
+                    resolve(response);
+                }
+            });
+        });
+    }, type);
+}
+
+//# sourceMappingURL=wait-for.js.map

package/dist/esm/internals/wait-for.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/wait-for.ts"],"sourcesContent":["import { HandlerType } from '@metamask/snaps-utils';\nimport { assert, createModuleLogger } from '@metamask/utils';\nimport { waitFor as waitForPuppeteer } from 'pptr-testing-library';\nimport { Page } from 'puppeteer';\n\nimport { SnapResponse } from '../types';\nimport { rootLogger } from './logger';\n\nexport type WaitForOptions = {\n  /**\n   * The timeout in milliseconds.\n   */\n  timeout?: number;\n\n  /**\n   * The error message to throw if the condition is not met.\n   */\n  message?: string;\n};\n\nconst log = createModuleLogger(rootLogger, 'wait-for');\n\n/**\n * Wait for a condition to be true. This is a wrapper around\n * `pptr-testing-library`'s `waitFor` function, with the addition of a custom\n * error message.\n *\n * @param fn - The condition to wait for.\n * @param options - The options.\n * @param options.timeout - The timeout in milliseconds.\n * @param options.message - The error message to throw if the condition is not\n * met.\n * @returns A promise that resolves when the condition is met. The promise\n * resolves to the return value of the condition function.\n */\nexport async function waitFor<Result>(\n  fn: () => Promise<Result>,\n  { timeout = 3000, message }: WaitForOptions = {},\n) {\n  try {\n    let result: Result | undefined;\n\n    await waitForPuppeteer(\n      // eslint-disable-next-line @typescript-eslint/no-misused-promises\n      async () => {\n        // Puppeteer's `waitFor` function does not support returning a value\n        // from the condition function, so we need to use a variable outside\n        // the scope of the function.\n        result = await fn();\n      },\n      {\n        timeout,\n      },\n    );\n\n    assert(result !== undefined);\n    return result;\n  } catch (error) {\n    if (message) {\n      throw new Error(message);\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Wait for a JSON-RPC response.\n *\n * @param page - The page to wait for the response on.\n * @param type - The type of response to wait for.\n * @returns The JSON-RPC response.\n */\nexport async function waitForResponse(\n  page: Page,\n  type:\n    | HandlerType.OnTransaction\n    | HandlerType.OnRpcRequest\n    | HandlerType.OnCronjob,\n) {\n  log('Waiting for response of type %s.', type);\n\n  return await page.evaluate(async (_type) => {\n    return new Promise<SnapResponse['response']>((resolve) => {\n      window.__SIMULATOR_API__.dispatch({\n        type: `${_type}/clearResponse`,\n      });\n\n      const unsubscribe = window.__SIMULATOR_API__.subscribe(() => {\n        const state = window.__SIMULATOR_API__.getState();\n        const { pending, response } = state[_type];\n\n        if (!pending && response) {\n          unsubscribe();\n\n          resolve(response);\n        }\n      });\n    });\n  }, type);\n}\n"],"names":["assert","createModuleLogger","waitFor","waitForPuppeteer","rootLogger","log","fn","timeout","message","result","undefined","error","Error","waitForResponse","page","type","evaluate","_type","Promise","resolve","window","__SIMULATOR_API__","dispatch","unsubscribe","subscribe","state","getState","pending","response"],"mappings":"AACA,SAASA,MAAM,EAAEC,kBAAkB,QAAQ,kBAAkB;AAC7D,SAASC,WAAWC,gBAAgB,QAAQ,uBAAuB;AAInE,SAASC,UAAU,QAAQ,WAAW;AActC,MAAMC,MAAMJ,mBAAmBG,YAAY;AAE3C;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeF,QACpBI,EAAyB,EACzB,EAAEC,UAAU,IAAI,EAAEC,OAAO,EAAkB,GAAG,CAAC,CAAC;IAEhD,IAAI;QACF,IAAIC;QAEJ,MAAMN,iBACJ,kEAAkE;QAClE;YACE,oEAAoE;YACpE,oEAAoE;YACpE,6BAA6B;YAC7BM,SAAS,MAAMH;QACjB,GACA;YACEC;QACF;QAGFP,OAAOS,WAAWC;QAClB,OAAOD;IACT,EAAE,OAAOE,OAAO;QACd,IAAIH,SAAS;YACX,MAAM,IAAII,MAAMJ;QAClB;QAEA,MAAMG;IACR;AACF;AAEA;;;;;;CAMC,GACD,OAAO,eAAeE,gBACpBC,IAAU,EACVC,IAGyB;IAEzBV,IAAI,oCAAoCU;IAExC,OAAO,MAAMD,KAAKE,QAAQ,CAAC,OAAOC;QAChC,OAAO,IAAIC,QAAkC,CAACC;YAC5CC,OAAOC,iBAAiB,CAACC,QAAQ,CAAC;gBAChCP,MAAM,CAAC,EAAEE,MAAM,cAAc,CAAC;YAChC;YAEA,MAAMM,cAAcH,OAAOC,iBAAiB,CAACG,SAAS,CAAC;gBACrD,MAAMC,QAAQL,OAAOC,iBAAiB,CAACK,QAAQ;gBAC/C,MAAM,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAGH,KAAK,CAACR,MAAM;gBAE1C,IAAI,CAACU,WAAWC,UAAU;oBACxBL;oBAEAJ,QAAQS;gBACV;YACF;QACF;IACF,GAAGb;AACL"}

package/dist/esm/matchers.js

@@ -0,0 +1,108 @@
+/* eslint-disable no-invalid-this */ // Note: Because this file imports from `@jest/globals`, it can only be used in
+// a Jest environment. This is why it's not exported from the index file.
+import { expect } from '@jest/globals';
+import { hasProperty } from '@metamask/utils';
+import { diff, matcherErrorMessage, matcherHint, printReceived, printWithType, RECEIVED_COLOR } from 'jest-matcher-utils';
+import { is } from 'superstruct';
+import { InterfaceStruct, SnapResponseStruct } from './internals';
+/**
+ * Ensure that the actual value is a response from the `request` function.
+ *
+ * @param actual - The actual value.
+ * @param matcherName - The name of the matcher.
+ * @param options - The matcher options.
+ */ function assertActualIsSnapResponse(actual, matcherName, options) {
+    if (!is(actual, SnapResponseStruct)) {
+        throw new Error(matcherErrorMessage(matcherHint(matcherName, undefined, undefined, options), `${RECEIVED_COLOR('received')} value must be a response from the \`request\` function`, printWithType('Received', actual, printReceived)));
+    }
+}
+/**
+ * Ensure that the actual value is a response from the `request` function, and
+ * that it has a `ui` property.
+ *
+ * @param actual - The actual value.
+ * @param matcherName - The name of the matcher.
+ * @param options - The matcher options.
+ */ function assertHasInterface(actual, matcherName, options) {
+    if (!is(actual, InterfaceStruct) || !actual.content) {
+        throw new Error(matcherErrorMessage(matcherHint(matcherName, undefined, undefined, options), `${RECEIVED_COLOR('received')} value must have a \`content\` property`, printWithType('Received', actual, printReceived)));
+    }
+}
+/**
+ * Check if a JSON-RPC response matches the expected value. This matcher is
+ * intended to be used with the `expect` global.
+ *
+ * @param actual - The actual response.
+ * @param expected - The expected response.
+ * @returns The status and message.
+ */ export const toRespondWith = function(actual, expected) {
+    assertActualIsSnapResponse(actual, 'toRespondWith');
+    const { response } = actual;
+    if (hasProperty(response, 'error')) {
+        const message = ()=>`${this.utils.matcherHint('.toRespondWith')}\n\n` + `Expected response: ${this.utils.printExpected(expected)}\n` + `Received error: ${this.utils.printReceived(response.error)}`;
+        return {
+            message,
+            pass: false
+        };
+    }
+    const pass = this.equals(response.result, expected);
+    const message = pass ? ()=>`${this.utils.matcherHint('.not.toRespondWith')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Received: ${this.utils.printReceived(response.result)}` : ()=>`${this.utils.matcherHint('.toRespondWith')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Received: ${this.utils.printReceived(response.result)}`;
+    return {
+        message,
+        pass
+    };
+};
+export const toRespondWithError = function(actual, expected) {
+    assertActualIsSnapResponse(actual, 'toRespondWithError');
+    const { response } = actual;
+    if (hasProperty(response, 'result')) {
+        const message = ()=>`${this.utils.matcherHint('.toRespondWithError')}\n\n` + `Expected error: ${this.utils.printExpected(expected)}\n` + `Received result: ${this.utils.printReceived(response.result)}`;
+        return {
+            message,
+            pass: false
+        };
+    }
+    const pass = this.equals(response.error, expected);
+    const message = pass ? ()=>`${this.utils.matcherHint('.not.toRespondWithError')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Received: ${this.utils.printReceived(response.error)}` : ()=>`${this.utils.matcherHint('.toRespondWithError')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Received: ${this.utils.printReceived(response.error)}`;
+    return {
+        message,
+        pass
+    };
+};
+/**
+ * Check if the snap sent a notification with the expected message. This matcher
+ * is intended to be used with the `expect` global.
+ *
+ * @param actual - The actual response.
+ * @param expected - The expected notification message.
+ * @param type - The expected notification type.
+ * @returns The status and message.
+ */ export const toSendNotification = async function(actual, expected, type) {
+    assertActualIsSnapResponse(actual, 'toSendNotification');
+    const { notifications } = actual;
+    const pass = notifications.some((notification)=>this.equals(notification.message, expected) && (type === undefined || notification.type === type));
+    const message = pass ? ()=>`${this.utils.matcherHint('.not.toSendNotification')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Expected type: ${this.utils.printExpected(type)}\n` + `Received: ${this.utils.printReceived(notifications)}` : ()=>`${this.utils.matcherHint('.toSendNotification')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Expected type: ${this.utils.printExpected(type)}\n` + `Received: ${this.utils.printReceived(notifications)}`;
+    return {
+        message,
+        pass
+    };
+};
+export const toRender = function(actual, expected) {
+    assertHasInterface(actual, 'toRender');
+    const { content } = actual;
+    const pass = this.equals(content, expected);
+    const difference = diff(expected, content);
+    const message = pass ? ()=>`${this.utils.matcherHint('.not.toShowInterface')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Received: ${this.utils.printReceived(content)}` + `${difference ? `\n\nDifference:\n\n${difference}` : ''}` : ()=>`${this.utils.matcherHint('.toShowInterface')}\n\n` + `Expected: ${this.utils.printExpected(expected)}\n` + `Received: ${this.utils.printReceived(content)}` + `${difference ? `\n\nDifference:\n\n${difference}` : ''}`;
+    return {
+        message,
+        pass
+    };
+};
+expect.extend({
+    toRespondWith,
+    toRespondWithError,
+    toSendNotification,
+    toRender
+});
+
+//# sourceMappingURL=matchers.js.map

package/dist/esm/matchers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/matchers.ts"],"sourcesContent":["/* eslint-disable no-invalid-this */\n\n// Note: Because this file imports from `@jest/globals`, it can only be used in\n// a Jest environment. This is why it's not exported from the index file.\n\nimport { expect } from '@jest/globals';\nimport { NotificationType } from '@metamask/rpc-methods';\nimport { Component } from '@metamask/snaps-ui';\nimport { EnumToUnion } from '@metamask/snaps-utils';\nimport { hasProperty, Json } from '@metamask/utils';\nimport type { MatcherFunction } from 'expect';\nimport {\n  diff,\n  matcherErrorMessage,\n  matcherHint,\n  MatcherHintOptions,\n  printReceived,\n  printWithType,\n  RECEIVED_COLOR,\n} from 'jest-matcher-utils';\nimport { is } from 'superstruct';\n\nimport { InterfaceStruct, SnapResponseStruct } from './internals';\nimport { SnapResponse } from './types';\n\n/**\n * Ensure that the actual value is a response from the `request` function.\n *\n * @param actual - The actual value.\n * @param matcherName - The name of the matcher.\n * @param options - The matcher options.\n */\nfunction assertActualIsSnapResponse(\n  actual: unknown,\n  matcherName: string,\n  options?: MatcherHintOptions,\n): asserts actual is SnapResponse {\n  if (!is(actual, SnapResponseStruct)) {\n    throw new Error(\n      matcherErrorMessage(\n        matcherHint(matcherName, undefined, undefined, options),\n        `${RECEIVED_COLOR(\n          'received',\n        )} value must be a response from the \\`request\\` function`,\n        printWithType('Received', actual, printReceived),\n      ),\n    );\n  }\n}\n\n/**\n * Ensure that the actual value is a response from the `request` function, and\n * that it has a `ui` property.\n *\n * @param actual - The actual value.\n * @param matcherName - The name of the matcher.\n * @param options - The matcher options.\n */\nfunction assertHasInterface(\n  actual: unknown,\n  matcherName: string,\n  options?: MatcherHintOptions,\n): asserts actual is { content: Component } {\n  if (!is(actual, InterfaceStruct) || !actual.content) {\n    throw new Error(\n      matcherErrorMessage(\n        matcherHint(matcherName, undefined, undefined, options),\n        `${RECEIVED_COLOR('received')} value must have a \\`content\\` property`,\n        printWithType('Received', actual, printReceived),\n      ),\n    );\n  }\n}\n\n/**\n * Check if a JSON-RPC response matches the expected value. This matcher is\n * intended to be used with the `expect` global.\n *\n * @param actual - The actual response.\n * @param expected - The expected response.\n * @returns The status and message.\n */\nexport const toRespondWith: MatcherFunction<[expected: Json]> = function (\n  actual,\n  expected,\n) {\n  assertActualIsSnapResponse(actual, 'toRespondWith');\n\n  const { response } = actual;\n  if (hasProperty(response, 'error')) {\n    const message = () =>\n      `${this.utils.matcherHint('.toRespondWith')}\\n\\n` +\n      `Expected response: ${this.utils.printExpected(expected)}\\n` +\n      `Received error: ${this.utils.printReceived(response.error)}`;\n\n    return { message, pass: false };\n  }\n\n  const pass = this.equals(response.result, expected);\n  const message = pass\n    ? () =>\n        `${this.utils.matcherHint('.not.toRespondWith')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Received: ${this.utils.printReceived(response.result)}`\n    : () =>\n        `${this.utils.matcherHint('.toRespondWith')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Received: ${this.utils.printReceived(response.result)}`;\n\n  return { message, pass };\n};\n\nexport const toRespondWithError: MatcherFunction<[expected: Json]> = function (\n  actual,\n  expected,\n) {\n  assertActualIsSnapResponse(actual, 'toRespondWithError');\n\n  const { response } = actual;\n  if (hasProperty(response, 'result')) {\n    const message = () =>\n      `${this.utils.matcherHint('.toRespondWithError')}\\n\\n` +\n      `Expected error: ${this.utils.printExpected(expected)}\\n` +\n      `Received result: ${this.utils.printReceived(response.result)}`;\n\n    return { message, pass: false };\n  }\n\n  const pass = this.equals(response.error, expected);\n  const message = pass\n    ? () =>\n        `${this.utils.matcherHint('.not.toRespondWithError')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Received: ${this.utils.printReceived(response.error)}`\n    : () =>\n        `${this.utils.matcherHint('.toRespondWithError')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Received: ${this.utils.printReceived(response.error)}`;\n\n  return { message, pass };\n};\n\n/**\n * Check if the snap sent a notification with the expected message. This matcher\n * is intended to be used with the `expect` global.\n *\n * @param actual - The actual response.\n * @param expected - The expected notification message.\n * @param type - The expected notification type.\n * @returns The status and message.\n */\nexport const toSendNotification: MatcherFunction<\n  [expected: string, type?: EnumToUnion<NotificationType> | undefined]\n> = async function (actual, expected, type) {\n  assertActualIsSnapResponse(actual, 'toSendNotification');\n\n  const { notifications } = actual;\n  const pass = notifications.some(\n    (notification) =>\n      this.equals(notification.message, expected) &&\n      (type === undefined || notification.type === type),\n  );\n\n  const message = pass\n    ? () =>\n        `${this.utils.matcherHint('.not.toSendNotification')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Expected type: ${this.utils.printExpected(type)}\\n` +\n        `Received: ${this.utils.printReceived(notifications)}`\n    : () =>\n        `${this.utils.matcherHint('.toSendNotification')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Expected type: ${this.utils.printExpected(type)}\\n` +\n        `Received: ${this.utils.printReceived(notifications)}`;\n\n  return { message, pass };\n};\n\nexport const toRender: MatcherFunction<[expected: Component]> = function (\n  actual,\n  expected,\n) {\n  assertHasInterface(actual, 'toRender');\n\n  const { content } = actual;\n  const pass = this.equals(content, expected);\n\n  const difference = diff(expected, content);\n\n  const message = pass\n    ? () =>\n        `${this.utils.matcherHint('.not.toShowInterface')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Received: ${this.utils.printReceived(content)}` +\n        `${difference ? `\\n\\nDifference:\\n\\n${difference}` : ''}`\n    : () =>\n        `${this.utils.matcherHint('.toShowInterface')}\\n\\n` +\n        `Expected: ${this.utils.printExpected(expected)}\\n` +\n        `Received: ${this.utils.printReceived(content)}` +\n        `${difference ? `\\n\\nDifference:\\n\\n${difference}` : ''}`;\n\n  return { message, pass };\n};\n\nexpect.extend({\n  toRespondWith,\n  toRespondWithError,\n  toSendNotification,\n  toRender,\n});\n"],"names":["expect","hasProperty","diff","matcherErrorMessage","matcherHint","printReceived","printWithType","RECEIVED_COLOR","is","InterfaceStruct","SnapResponseStruct","assertActualIsSnapResponse","actual","matcherName","options","Error","undefined","assertHasInterface","content","toRespondWith","expected","response","message","utils","printExpected","error","pass","equals","result","toRespondWithError","toSendNotification","type","notifications","some","notification","toRender","difference","extend"],"mappings":"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"}

package/dist/esm/options.js

@@ -0,0 +1,26 @@
+import { boolean, create, defaulted, number, object, optional, string, type } from 'superstruct';
+const SnapsEnvironmentOptionsStruct = type({
+    executionEnvironmentUrl: optional(string()),
+    simulatorUrl: optional(string()),
+    keepAlive: defaulted(boolean(), false),
+    server: defaulted(object({
+        enabled: defaulted(boolean(), true),
+        port: defaulted(number(), 0),
+        root: defaulted(string(), process.cwd())
+    }), {}),
+    browser: defaulted(object({
+        headless: defaulted(boolean(), true)
+    }), {})
+});
+/**
+ * Get the environment options. This validates the options, and returns the
+ * default options if none are provided.
+ *
+ * @param testEnvironmentOptions - The test environment options as defined in
+ * the Jest configuration.
+ * @returns The environment options.
+ */ export function getOptions(testEnvironmentOptions) {
+    return create(testEnvironmentOptions, SnapsEnvironmentOptionsStruct);
+}
+
+//# sourceMappingURL=options.js.map

package/dist/esm/options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/options.ts"],"sourcesContent":["import {\n  boolean,\n  create,\n  defaulted,\n  Infer,\n  number,\n  object,\n  optional,\n  string,\n  type,\n} from 'superstruct';\n\nconst SnapsEnvironmentOptionsStruct = type({\n  executionEnvironmentUrl: optional(string()),\n  simulatorUrl: optional(string()),\n  keepAlive: defaulted(boolean(), false),\n\n  server: defaulted(\n    object({\n      enabled: defaulted(boolean(), true),\n      port: defaulted(number(), 0),\n      root: defaulted(string(), process.cwd()),\n    }),\n    {},\n  ),\n\n  browser: defaulted(\n    object({\n      headless: defaulted(boolean(), true),\n    }),\n    {},\n  ),\n});\n\n/**\n * The options for the environment. These can be specified in the Jest\n * configuration under `testEnvironmentOptions`.\n *\n * @example\n * ```json\n * {\n *   \"testEnvironment\": \"@metamask/snaps-jest\",\n *   \"testEnvironmentOptions\": {\n *     \"executionEnvironmentUrl\": \"http://localhost:8080\",\n *     \"server\": {\n *       \"port\": 8080,\n *       /* ... *\\/\n *     }\n *   }\n * }\n * ```\n * @property executionEnvironmentUrl - The URL of the execution environment. If\n * this is not provided, the execution environment will be served from the\n * built-in HTTP server.\n * @property simulatorUrl - The URL of the simulator. If this is not provided,\n * the simulator will be served from the built-in HTTP server.\n * @property keepAlive - Whether to keep the browser open after the tests have\n * finished. This is useful for debugging. Defaults to `false`.\n * @property server - The options for the built-in HTTP server.\n * @property server.enabled - Whether to run the built-in HTTP server. Defaults\n * to `true`.\n * @property server.port - The port to use for the built-in HTTP server. If this\n * is not provided, a random available port will be used.\n * @property server.root - The root directory to serve from the built-in HTTP\n * server. Defaults to the current working directory. This is assumed to be the\n * directory containing the snap manifest and `dist` files. If this is a\n * relative path, it will be resolved relative to the current working directory.\n * @property browser - The options for the browser.\n * @property browser.headless - Whether to run the browser in headless mode.\n * Defaults to `true`.\n */\nexport type SnapsEnvironmentOptions = Infer<\n  typeof SnapsEnvironmentOptionsStruct\n>;\n\n/**\n * Get the environment options. This validates the options, and returns the\n * default options if none are provided.\n *\n * @param testEnvironmentOptions - The test environment options as defined in\n * the Jest configuration.\n * @returns The environment options.\n */\nexport function getOptions(testEnvironmentOptions: Record<string, unknown>) {\n  return create(testEnvironmentOptions, SnapsEnvironmentOptionsStruct);\n}\n"],"names":["boolean","create","defaulted","number","object","optional","string","type","SnapsEnvironmentOptionsStruct","executionEnvironmentUrl","simulatorUrl","keepAlive","server","enabled","port","root","process","cwd","browser","headless","getOptions","testEnvironmentOptions"],"mappings":"AAAA,SACEA,OAAO,EACPC,MAAM,EACNC,SAAS,EAETC,MAAM,EACNC,MAAM,EACNC,QAAQ,EACRC,MAAM,EACNC,IAAI,QACC,cAAc;AAErB,MAAMC,gCAAgCD,KAAK;IACzCE,yBAAyBJ,SAASC;IAClCI,cAAcL,SAASC;IACvBK,WAAWT,UAAUF,WAAW;IAEhCY,QAAQV,UACNE,OAAO;QACLS,SAASX,UAAUF,WAAW;QAC9Bc,MAAMZ,UAAUC,UAAU;QAC1BY,MAAMb,UAAUI,UAAUU,QAAQC,GAAG;IACvC,IACA,CAAC;IAGHC,SAAShB,UACPE,OAAO;QACLe,UAAUjB,UAAUF,WAAW;IACjC,IACA,CAAC;AAEL;AA2CA;;;;;;;CAOC,GACD,OAAO,SAASoB,WAAWC,sBAA+C;IACxE,OAAOpB,OAAOoB,wBAAwBb;AACxC"}

package/dist/esm/setup.js

@@ -0,0 +1,6 @@
+// Setup file for Jest. This file is used in the Jest preset configuration, and
+// not intended to be exported or used directly.
+// eslint-disable-next-line import/no-unassigned-import
+import './matchers';
+
+//# sourceMappingURL=setup.js.map

package/dist/esm/setup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/setup.ts"],"sourcesContent":["// Setup file for Jest. This file is used in the Jest preset configuration, and\n// not intended to be exported or used directly.\n\n// eslint-disable-next-line import/no-unassigned-import\nimport './matchers';\n"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,gDAAgD;AAEhD,uDAAuD;AACvD,OAAO,aAAa"}

package/dist/esm/types.js

@@ -0,0 +1,3 @@
+export { NotificationType } from '@metamask/rpc-methods';
+
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["import { NotificationType } from '@metamask/rpc-methods';\nimport { Component } from '@metamask/snaps-ui';\nimport { EnumToUnion } from '@metamask/snaps-utils';\nimport { JsonRpcId, JsonRpcParams } from '@metamask/utils';\nimport { Infer } from 'superstruct';\n\nimport {\n  Mock,\n  MockJsonRpcOptions,\n  MockOptions,\n  SnapOptionsStruct,\n  SnapResponseStruct,\n  TransactionOptionsStruct,\n} from './internals';\n\n/* eslint-disable @typescript-eslint/consistent-type-definitions */\ndeclare module 'expect' {\n  interface AsymmetricMatchers {\n    toRespondWith(response: unknown): void;\n    toRespondWithError(error: unknown): void;\n    toSendNotification(\n      message: string,\n      type?: EnumToUnion<NotificationType>,\n    ): void;\n    toRender(component: Component): void;\n  }\n\n  // Ideally we would use `Matchers<Result>` instead of `Matchers<R>`, but\n  // TypeScript doesn't allow this:\n  // TS2428: All declarations of 'Matchers' must have identical type parameters.\n  interface Matchers<R> {\n    toRespondWith(response: unknown): R;\n    toRespondWithError(error: unknown): R;\n    toSendNotification(\n      message: string,\n      type?: EnumToUnion<NotificationType>,\n    ): R;\n    toRender(component: Component): R;\n  }\n}\n/* eslint-enable @typescript-eslint/consistent-type-definitions */\n\n/**\n * Deeply partialize a type.\n *\n * @template Type - The type to partialize.\n * @returns The deeply partialized type.\n * @example\n * ```ts\n * type Foo = {\n *   bar: {\n *     baz: string;\n *   };\n *   qux: number;\n * };\n *\n * type PartialFoo = DeepPartial<Foo>;\n * // { bar?: { baz?: string; }; qux?: number; }\n * ```\n */\nexport type DeepPartial<Type> = {\n  [Key in keyof Type]?: Type[Key] extends Record<string, unknown>\n    ? DeepPartial<Type[Key]>\n    : Type[Key];\n};\n\nexport type RequestOptions = {\n  /**\n   * The JSON-RPC request ID.\n   */\n  id?: JsonRpcId;\n\n  /**\n   * The JSON-RPC method.\n   */\n  method: string;\n\n  /**\n   * The JSON-RPC params.\n   */\n  params?: JsonRpcParams;\n\n  /**\n   * The origin to send the request from.\n   */\n  origin?: string;\n};\n\n/**\n * The `runCronjob` options. This is the same as {@link RequestOptions}, except\n * that it does not have an `origin` property.\n */\nexport type CronjobOptions = Omit<RequestOptions, 'origin'>;\n\n/**\n * The options to use for transaction requests.\n *\n * @property chainId - The CAIP-2 chain ID to send the transaction on. Defaults\n * to `eip155:1`.\n * @property origin - The origin to send the transaction from. Defaults to\n * `metamask.io`.\n * @property from - The address to send the transaction from. Defaults to a\n * randomly generated address.\n * @property to - The address to send the transaction to. Defaults to a randomly\n * generated address.\n * @property value - The value to send with the transaction. Defaults to `0`.\n * @property data - The data to send with the transaction. Defaults to `0x`.\n * @property gasLimit - The gas limit to use for the transaction. Defaults to\n * `21_000`.\n * @property maxFeePerGas - The maximum fee per gas to use for the transaction.\n * Defaults to `1`.\n * @property maxPriorityFeePerGas - The maximum priority fee per gas to use for\n * the transaction. Defaults to `1`.\n * @property nonce - The nonce to use for the transaction. Defaults to `0`.\n */\nexport type TransactionOptions = Infer<typeof TransactionOptionsStruct>;\n\n/**\n * The options to use for requests to the snap.\n *\n * @property timeout - The timeout in milliseconds to use. Defaults to `1000`.\n */\nexport type SnapOptions = Infer<typeof SnapOptionsStruct>;\n\n/**\n * A `snap_dialog` alert interface.\n */\nexport type SnapAlertInterface = {\n  /**\n   * The type of the interface. This is always `alert`.\n   */\n  type: 'alert';\n\n  /**\n   * The content to show in the alert.\n   */\n  content: Component;\n\n  /**\n   * Close the alert.\n   */\n  ok(): Promise<void>;\n};\n\n/**\n * A `snap_dialog` confirmation interface.\n */\nexport type SnapConfirmationInterface = {\n  /**\n   * The type of the interface. This is always `confirmation`.\n   */\n  type: 'confirmation';\n\n  /**\n   * The content to show in the confirmation.\n   */\n  content: Component;\n\n  /**\n   * Close the confirmation.\n   */\n  ok(): Promise<void>;\n\n  /**\n   * Cancel the confirmation.\n   */\n  cancel(): Promise<void>;\n};\n\n/**\n * A `snap_dialog` prompt interface.\n */\nexport type SnapPromptInterface = {\n  /**\n   * The type of the interface. This is always `prompt`.\n   */\n  type: 'prompt';\n\n  /**\n   * The content to show in the prompt.\n   */\n  content: Component;\n\n  /**\n   * Close the prompt.\n   *\n   * @param value - The value to close the prompt with.\n   */\n  ok(value?: string): Promise<void>;\n\n  /**\n   * Cancel the prompt.\n   */\n  cancel(): Promise<void>;\n};\n\nexport type SnapInterface =\n  | SnapAlertInterface\n  | SnapConfirmationInterface\n  | SnapPromptInterface;\n\nexport type SnapRequestObject = {\n  /**\n   * Get a user interface object from a snap. This will throw an error if the\n   * snap does not show a user interface within the timeout.\n   *\n   * @param options - The options to use.\n   * @param options.timeout - The timeout in milliseconds to use. Defaults to\n   * `1000`.\n   * @returns The user interface object.\n   */\n  getInterface(options?: SnapOptions): Promise<SnapInterface>;\n};\n\n/**\n * A pending request object. This is a promise with extra\n * {@link SnapRequestObject} fields.\n */\nexport type SnapRequest = Promise<SnapResponse> & SnapRequestObject;\n\n/**\n * This is the main entry point to interact with the snap. It is returned by\n * {@link installSnap}, and has methods to send requests to the snap.\n *\n * @example\n * ```ts\n * import { installSnap } from '@metamask/snaps-jest';\n *\n * const snap = await installSnap();\n * const response = await snap.request({ method: 'hello' });\n *\n * expect(response).toRespondWith('Hello, world!');\n * ```\n */\nexport type Snap = {\n  /**\n   * Send a JSON-RPC request to the snap.\n   *\n   * @param request - The request. This is similar to a JSON-RPC request, but\n   * has an extra `origin` field.\n   * @returns The response promise, with extra {@link SnapRequestObject} fields.\n   */\n  request(request: RequestOptions): SnapRequest;\n\n  /**\n   * Send a transaction to the snap.\n   *\n   * @param transaction - The transaction. This is similar to an Ethereum\n   * transaction object, but has an extra `origin` field. Any missing fields\n   * will be filled in with default values.\n   * @returns The response.\n   */\n  sendTransaction(\n    transaction?: Partial<TransactionOptions>,\n  ): Promise<SnapResponse>;\n\n  /**\n   * Run a cronjob in the snap. This is similar to {@link request}, but the\n   * request will be sent to the `onCronjob` method of the snap.\n   *\n   * @param cronjob - The cronjob request. This is similar to a JSON-RPC\n   * request, and is normally specified in the snap manifest, under the\n   * `endowment:cronjob` permission.\n   * @returns The response promise, with extra {@link SnapRequestObject} fields.\n   */\n  runCronjob(cronjob: CronjobOptions): SnapRequest;\n\n  /**\n   * Close the page running the snap. This is mainly useful for cleaning up\n   * the test environment, and calling it is not strictly necessary.\n   *\n   * @returns A promise that resolves when the page is closed.\n   */\n  // TODO: Find a way to do this automatically.\n  close(): Promise<void>;\n\n  /**\n   * Enable network mocking for the snap.\n   *\n   * @param options - The options for the network mocking.\n   * @returns A {@link Mock} object, with an `unmock` function.\n   */\n  mock(options: DeepPartial<MockOptions>): Promise<Mock>;\n\n  /**\n   * Enable JSON-RPC provider mocking for the snap. This will mock any requests\n   * sent through the `ethereum` global, with the specified `method`.\n   *\n   * @param options - The options for the JSON-RPC mocking.\n   * @param options.method - The JSON-RPC method to mock, e.g.,\n   * `eth_blockNumber`.\n   * @param options.result - The JSON value to return.\n   * @returns A {@link Mock} object, with an `unmock` function.\n   */\n  mockJsonRpc(options: MockJsonRpcOptions): Promise<Mock>;\n};\n\nexport type SnapResponse = Infer<typeof SnapResponseStruct>;\n\nexport { NotificationType } from '@metamask/rpc-methods';\n"],"names":["NotificationType"],"mappings":"AA2SA,SAASA,gBAAgB,QAAQ,wBAAwB"}

package/dist/types/environment.d.ts

@@ -0,0 +1,53 @@
+import { EnvironmentContext, JestEnvironmentConfig } from '@jest/environment';
+import NodeEnvironment from 'jest-environment-node';
+declare global {
+    const browser: WebdriverIO.Browser;
+    const snapsEnvironment: SnapsEnvironment;
+}
+export declare class SnapsEnvironment extends NodeEnvironment {
+    #private;
+    browser: WebdriverIO.Browser;
+    /**
+     * Constructor.
+     *
+     * @param options - The environment options.
+     * @param context - The environment context.
+     */
+    constructor(options: JestEnvironmentConfig, context: EnvironmentContext);
+    /**
+     * Set up the environment. This starts the built-in HTTP server, and creates a
+     * new browser instance.
+     */
+    setup(): Promise<void>;
+    /**
+     * Tear down the environment. This closes the browser, and stops the built-in
+     * HTTP server.
+     */
+    teardown(): Promise<void>;
+    /**
+     * Get the URL to the simulator, including the environment URL.
+     *
+     * @returns The simulator URL.
+     * @throws If the server is not running.
+     */
+    get url(): string;
+    /**
+     * Get the snap ID for the current environment, which is used if no snap ID is
+     * passed to {@link installSnap}. This assumes that the built-in server is
+     * running.
+     *
+     * @returns The snap ID.
+     * @throws If the server is not running.
+     */
+    get snapId(): string;
+    /**
+     * Create a new page, and attach logging handlers.
+     *
+     * @param url - The page URL. Defaults to the specified Snaps Simulator URL,
+     * or the default simulator URL if none is specified.
+     * @param timeout - The page timeout, in milliseconds.
+     * @returns The new page.
+     */
+    createPage(url?: string, timeout?: number): Promise<import("puppeteer").Page>;
+}
+export default SnapsEnvironment;

package/dist/types/helpers.d.ts

@@ -0,0 +1,28 @@
+import type { Snap } from './types';
+/**
+ * Load a snap into the environment. This is the main entry point for testing
+ * snaps: It returns a {@link Snap} object that can be used to interact with the
+ * snap.
+ *
+ * @example
+ * ```ts
+ * import { installSnap } from '@metamask/snaps-jest';
+ *
+ * describe('My Snap', () => {
+ *   it('should do something', async () => {
+ *     const { request } = await installSnap('local:my-snap');
+ *     const response = await request({
+ *       method: 'foo',
+ *       params: ['bar'],
+ *     });
+ *     expect(response).toRespondWith('bar');
+ *   });
+ * });
+ * ```
+ * @param snapId - The ID of the snap, including the prefix (`local:`). Defaults
+ * to the URL of the built-in server, if it is running. This supports both
+ * local snap IDs and NPM snap IDs.
+ * @returns The snap.
+ * @throws If the built-in server is not running, and no snap ID is provided.
+ */
+export declare function installSnap(snapId?: string): Promise<Snap>;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { default, default as TestEnvironment } from './environment';
+export * from './helpers';
+export * from './options';
+export * from './types';

package/dist/types/internals/environment.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the Snaps environment. This asserts that the environment has been
+ * configured.
+ *
+ * @returns The Snaps environment.
+ */
+export declare function getEnvironment(): import("..").default;

package/dist/types/internals/index.d.ts

@@ -0,0 +1,9 @@
+export * from './environment';
+export * from './interface';
+export * from './logger';
+export * from './network';
+export * from './request';
+export * from './server';
+export * from './structs';
+export * from './types';
+export * from './wait-for';

package/dist/types/internals/interface.d.ts

@@ -0,0 +1,25 @@
+import { Page } from 'puppeteer';
+import { SnapInterface, SnapOptions } from '../types';
+/**
+ * Get the current snap user interface (i.e., dialog). This will throw an error
+ * if the snap does not show a user interface within the timeout.
+ *
+ * @param page - The page to get the interface from.
+ * @param options - The options to use.
+ * @param options.timeout - The timeout in milliseconds to use. Defaults to
+ * `1000`.
+ * @returns The user interface object.
+ */
+export declare function getInterface(page: Page, options?: SnapOptions): Promise<SnapInterface>;
+/**
+ * Get the text of the notifications.
+ *
+ * @param page - The page to get the notifications from.
+ * @param requestId - The ID of the request to get the notifications for.
+ * @returns The text of the notifications, in order of appearance.
+ */
+export declare function getNotifications(page: Page, requestId: string): Promise<{
+    id: string;
+    message: string;
+    type: "native" | "inApp";
+}[]>;

package/dist/types/internals/logger.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="debug" />
+export declare const rootLogger: import("debug").Debugger;

package/dist/types/internals/network.d.ts

@@ -0,0 +1,87 @@
+import { Page, HTTPRequest } from 'puppeteer';
+import { Infer, Struct } from 'superstruct';
+import { DeepPartial } from '../types';
+export declare type Unmock = () => Promise<void>;
+export declare type Mock = {
+    /**
+     * A function that can be used to unmock the URL.
+     */
+    unmock: Unmock;
+};
+/**
+ * A function that can return `true` if the given request should be mocked, or
+ * false if not.
+ *
+ * @param request - The request to check.
+ * @returns Whether to mock the request.
+ */
+export declare type ConditionFunction = (request: HTTPRequest) => boolean;
+export declare const MockOptionsStruct: Struct<{
+    response: {
+        headers: Record<string, unknown>;
+        status: number;
+        body: string;
+        contentType: string;
+    };
+    url: string | RegExp;
+    partial?: boolean | undefined;
+} | {
+    response: {
+        headers: Record<string, unknown>;
+        status: number;
+        body: string;
+        contentType: string;
+    };
+    condition: ConditionFunction;
+}, null>;
+/**
+ * The options for the network mocking.
+ *
+ * @property url - The URL to mock. If a string is provided, the URL will be
+ * matched exactly. If a RegExp is provided, the URL will be matched against it.
+ * This option is incompatible with the `condition` option.
+ * @property partial - If enabled, the request will be mocked if the URL starts
+ * with the given URL. This option is ignored if a RegExp is provided to the
+ * `url` option. This option is incompatible with the `condition` option.
+ * @property condition - A function which gets the {@link HTTPRequest} as
+ * parameter and returns a boolean to indicate whether the response should be
+ * mocked or not. This option is incompatible with the `url` and `partial`
+ * options.
+ * @property response - The response to send for the request.
+ * @property response.status - The status code to send for the response.
+ * Defaults to `200`.
+ * @property response.headers - The headers to send for the response. Defaults
+ * to headers that enable CORS.
+ * @property response.contentType - The content type to send for the response.
+ * Defaults to `text/plain`.
+ */
+export declare type MockOptions = Infer<typeof MockOptionsStruct>;
+/**
+ * Enable network mocking for the given page, and all its sub-frames.
+ *
+ * @param page - The page to enable network mocking on.
+ * @param options - The options for the network mocking.
+ * @returns A {@link Mock} object, with an `unmock` function.
+ */
+export declare function mock(page: Page, options: DeepPartial<MockOptions>): Promise<Mock>;
+declare const MockJsonRpcOptionsStruct: Struct<{
+    method: string;
+    result: import("@metamask/utils").Json;
+}, {
+    method: Struct<string, null>;
+    result: Struct<import("@metamask/utils").Json, unknown>;
+}>;
+export declare type MockJsonRpcOptions = Infer<typeof MockJsonRpcOptionsStruct>;
+/**
+ * Mock an Ethereum JSON-RPC request. This intercepts all requests to the
+ * Ethereum provider, and returns the `result` instead.
+ *
+ * @param page - The page to enable network JSON-RPC mocking on.
+ * @param options - The options for the JSON-RPC mock.
+ * @param options.method - The JSON-RPC method to mock. Any other methods will be
+ * forwarded to the provider.
+ * @param options.result - The JSON response to return.
+ * @returns A {@link Mock} object, with an `unmock` function.
+ */
+export declare function mockJsonRpc(page: Page, { method, result }: MockJsonRpcOptions): Promise<Mock>;
+export {};

package/dist/types/internals/request.d.ts

@@ -0,0 +1,58 @@
+import { HandlerType } from '@metamask/snaps-utils';
+import { Page } from 'puppeteer';
+import { CronjobOptions, RequestOptions, SnapRequest, TransactionOptions } from '../types';
+/**
+ * Send a request to the snap.
+ *
+ * @param page - The page to send the request from.
+ * @param options - The request options.
+ * @param options.origin - The origin of the request. Defaults to `metamask.io`.
+ * @param handler - The handler to use. Defaults to `onRpcRequest`.
+ * @returns The response.
+ */
+export declare function request(page: Page, { origin, ...options }: RequestOptions, handler?: HandlerType.OnRpcRequest | HandlerType.OnCronjob): SnapRequest;
+/**
+ * Send a transaction to the snap.
+ *
+ * @param page - The page to send the transaction from.
+ * @param options - The transaction options.
+ * @returns The response.
+ */
+export declare function sendTransaction(page: Page, options: Partial<TransactionOptions>): Promise<{
+    id: string;
+    response: ({
+        result: import("@metamask/utils").Json;
+    } | {
+        error: import("@metamask/utils").Json;
+    }) & Record<"error", unknown>;
+    notifications: never[];
+    content?: undefined;
+} | {
+    id: string;
+    response: {
+        result: import("@metamask/utils").Json;
+    };
+    notifications: never[];
+    content: import("@metamask/snaps-ui").Panel | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Copyable;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Divider;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Heading;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Spinner;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Text;
+    };
+}>;
+/**
+ * Run a cronjob.
+ *
+ * @param page - The page to run the cronjob from.
+ * @param options - The request options.
+ * @returns The response.
+ */
+export declare function runCronjob(page: Page, options: CronjobOptions): SnapRequest;

package/dist/types/internals/server.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import { SnapsEnvironmentOptions } from '../options';
+export declare type ServerOptions = Required<Required<SnapsEnvironmentOptions>['server']>;
+/**
+ * Start an HTTP server on `localhost` with a random port. This is used to serve
+ * the static files for the environment.
+ *
+ * @param options - The options to use.
+ * @param options.port - The port to use for the server.
+ * @param options.root - The root directory to serve from the server.
+ * @returns The HTTP server.
+ */
+export declare function startServer(options: ServerOptions): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;