Add more tests

Author: FrederikBolding

packages/snaps-controllers/coverage.json

@@ -1,6 +1,6 @@
 {
-  "branches": 92.89,
-  "functions": 96.71,
-  "lines": 98,
-  "statements": 97.71
+  "branches": 93.11,
+  "functions": 96.79,
+  "lines": 98.06,
+  "statements": 97.77
 }

packages/snaps-controllers/src/multichain/MultichainRoutingController.test.ts

@@ -198,4 +198,97 @@ describe('MultichainRoutingController', () => {
       }),
     ).rejects.toThrow('The method does not exist / is not available');
   });
+
+  it('throws if address resolution fails', async () => {
+    const rootMessenger = getRootMultichainRoutingControllerMessenger();
+    const messenger =
+      getRestrictedMultichainRoutingControllerMessenger(rootMessenger);
+
+    /* eslint-disable-next-line no-new */
+    new MultichainRoutingController({
+      messenger,
+    });
+
+    rootMessenger.registerActionHandler(
+      'AccountsController:listMultichainAccounts',
+      () => MOCK_SOLANA_ACCOUNTS,
+    );
+
+    rootMessenger.registerActionHandler(
+      'PermissionController:getPermissions',
+      () => MOCK_SOLANA_SNAP_PERMISSIONS,
+    );
+
+    rootMessenger.registerActionHandler(
+      'SnapController:handleRequest',
+      async ({ handler }) => {
+        if (handler === HandlerType.OnKeyringRequest) {
+          // Simulate the Snap returning a bogus address
+          return { address: 'foo' };
+        }
+        throw new Error('Unmocked request');
+      },
+    );
+
+    await expect(
+      messenger.call('MultichainRoutingController:handleRequest', {
+        connectedAddresses: SOLANA_CONNECTED_ACCOUNTS,
+        scope: SOLANA_CAIP2,
+        request: {
+          method: 'signAndSendTransaction',
+          params: {
+            message: 'foo',
+          },
+        },
+      }),
+    ).rejects.toThrow('Internal JSON-RPC error');
+  });
+
+  it('throws if address resolution returns an address that isnt available', async () => {
+    const rootMessenger = getRootMultichainRoutingControllerMessenger();
+    const messenger =
+      getRestrictedMultichainRoutingControllerMessenger(rootMessenger);
+
+    /* eslint-disable-next-line no-new */
+    new MultichainRoutingController({
+      messenger,
+    });
+
+    rootMessenger.registerActionHandler(
+      'AccountsController:listMultichainAccounts',
+      () => MOCK_SOLANA_ACCOUNTS,
+    );
+
+    rootMessenger.registerActionHandler(
+      'PermissionController:getPermissions',
+      () => MOCK_SOLANA_SNAP_PERMISSIONS,
+    );
+
+    rootMessenger.registerActionHandler(
+      'SnapController:handleRequest',
+      async ({ handler }) => {
+        if (handler === HandlerType.OnKeyringRequest) {
+          // Simulate the Snap returning an unconnected address
+          return {
+            address:
+              'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:7S3P4HxJpyyigGzodYwHtCxZyUQe9JiBMHyRWXArAaKa',
+          };
+        }
+        throw new Error('Unmocked request');
+      },
+    );
+
+    await expect(
+      messenger.call('MultichainRoutingController:handleRequest', {
+        connectedAddresses: SOLANA_CONNECTED_ACCOUNTS,
+        scope: SOLANA_CAIP2,
+        request: {
+          method: 'signAndSendTransaction',
+          params: {
+            message: 'foo',
+          },
+        },
+      }),
+    ).rejects.toThrow('Invalid method parameter(s)');
+  });
 });

packages/snaps-execution-environments/src/common/BaseSnapExecutor.test.browser.ts

@@ -1567,6 +1567,48 @@ describe('BaseSnapExecutor', () => {
     });
   });
 
+  it('supports onProtocolRequest export', async () => {
+    const CODE = `
+      module.exports.onProtocolRequest = ({ origin, scope, request }) => ({ origin, scope, request })
+    `;
+
+    const executor = new TestSnapExecutor();
+    await executor.executeSnap(1, MOCK_SNAP_ID, CODE, []);
+
+    expect(await executor.readCommand()).toStrictEqual({
+      jsonrpc: '2.0',
+      id: 1,
+      result: 'OK',
+    });
+
+    const params = {
+      scope: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      request: {
+        jsonrpc: '2.0',
+        id: 'foo',
+        method: 'getVersion',
+      },
+    };
+
+    await executor.writeCommand({
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'snapRpc',
+      params: [
+        MOCK_SNAP_ID,
+        HandlerType.OnProtocolRequest,
+        MOCK_ORIGIN,
+        { jsonrpc: '2.0', method: '', params },
+      ],
+    });
+
+    expect(await executor.readCommand()).toStrictEqual({
+      id: 2,
+      jsonrpc: '2.0',
+      result: { origin: MOCK_ORIGIN, ...params },
+    });
+  });
+
   describe('lifecycle hooks', () => {
     const LIFECYCLE_HOOKS = [HandlerType.OnInstall, HandlerType.OnUpdate];
 

packages/snaps-execution-environments/src/common/validation.test.ts

@@ -2,6 +2,7 @@ import { UserInputEventType } from '@metamask/snaps-sdk';
 
 import {
   assertIsOnNameLookupRequestArguments,
+  assertIsOnProtocolRequestArguments,
   assertIsOnSignatureRequestArguments,
   assertIsOnTransactionRequestArguments,
   assertIsOnUserInputRequestArguments,
@@ -232,3 +233,68 @@ describe('assertIsOnUserInputRequestArguments', () => {
     );
   });
 });
+
+describe('assertIsOnProtocolRequestArguments', () => {
+  it.each([
+    {
+      scope: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      request: {
+        jsonrpc: '2.0',
+        id: 'foo',
+        method: 'getVersion',
+      },
+    },
+    {
+      scope: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      request: {
+        jsonrpc: '2.0',
+        id: 'foo',
+        method: 'getVersion',
+        params: {
+          foo: 'bar',
+        },
+      },
+    },
+  ])('does not throw for a valid protocol request param object', (value) => {
+    expect(() => assertIsOnProtocolRequestArguments(value)).not.toThrow();
+  });
+
+  it.each([
+    true,
+    false,
+    null,
+    undefined,
+    0,
+    1,
+    '',
+    'foo',
+    [],
+    {},
+    { request: { foo: 'bar' } },
+    {
+      request: {
+        jsonrpc: '2.0',
+        id: 'foo',
+        method: 'getVersion',
+        params: {
+          foo: 'bar',
+        },
+      },
+    },
+    {
+      scope: 'foo',
+      request: {
+        jsonrpc: '2.0',
+        id: 'foo',
+        method: 'getVersion',
+      },
+    },
+  ])(
+    'throws if the value is not a valid protocol request params object',
+    (value) => {
+      expect(() => assertIsOnProtocolRequestArguments(value as any)).toThrow(
+        'Invalid request params:',
+      );
+    },
+  );
+});

packages/snaps-rpc-methods/jest.config.js

@@ -10,10 +10,10 @@ module.exports = deepmerge(baseConfig, {
   ],
   coverageThreshold: {
     global: {
-      branches: 92.94,
-      functions: 97.26,
-      lines: 97.87,
-      statements: 97.39,
+      branches: 93.2,
+      functions: 97.89,
+      lines: 98.03,
+      statements: 97.56,
     },
   },
 });

packages/snaps-simulation/src/methods/specifications.test.ts

@@ -123,6 +123,19 @@ describe('getPermissionSpecifications', () => {
           ],
           "targetName": "endowment:page-home",
         },
+        "endowment:protocol": {
+          "allowedCaveats": [
+            "protocolSnapScopes",
+            "maxRequestTime",
+          ],
+          "endowmentGetter": [Function],
+          "permissionType": "Endowment",
+          "subjectTypes": [
+            "snap",
+          ],
+          "targetName": "endowment:protocol",
+          "validator": [Function],
+        },
         "endowment:rpc": {
           "allowedCaveats": [
             "rpcOrigin",

packages/snaps-utils/coverage.json

@@ -2,5 +2,5 @@
   "branches": 99.74,
   "functions": 98.93,
   "lines": 99.46,
-  "statements": 96.37
+  "statements": 96.31
 }