Add unit tests

Author: david0xd

packages/snaps-controllers/coverage.json

@@ -1,6 +1,6 @@
 {
-  "branches": 93.48,
-  "functions": 97.38,
-  "lines": 98.34,
-  "statements": 98.08
+  "branches": 93.57,
+  "functions": 97.41,
+  "lines": 98.36,
+  "statements": 98.1
 }

packages/snaps-controllers/src/snaps/SnapController.test.tsx

@@ -11061,4 +11061,108 @@ describe('SnapController', () => {
       snapController.destroy();
     });
   });
+
+  describe('SnapController:trackEvent', () => {
+    it('should track event for allowed handler', async () => {
+      const mockTrackEvent = jest.fn();
+      const rootMessenger = getControllerMessenger();
+      const executionEnvironmentStub = new ExecutionEnvironmentStub(
+        getNodeEESMessenger(rootMessenger),
+      ) as unknown as NodeThreadExecutionService;
+
+      const [snapController] = getSnapControllerWithEES(
+        getSnapControllerWithEESOptions({
+          rootMessenger,
+          trackEvent: mockTrackEvent,
+          state: {
+            snaps: getPersistedSnapsState(),
+          },
+        }),
+        executionEnvironmentStub,
+      );
+
+      const snap = snapController.getExpect(MOCK_SNAP_ID);
+      await snapController.startSnap(snap.id);
+
+      await snapController.handleRequest({
+        snapId: snap.id,
+        origin: MOCK_ORIGIN,
+        handler: HandlerType.OnRpcRequest,
+        request: {
+          jsonrpc: '2.0',
+          method: 'test',
+          params: {},
+          id: 1,
+        },
+      });
+
+      expect(mockTrackEvent).toHaveBeenCalledTimes(1);
+      expect(mockTrackEvent).toHaveBeenCalledWith({
+        category: 'Snaps',
+        event: 'SnapExportUsed',
+        properties: {
+          export: 'onRpcRequest',
+          origin: 'https://example.com',
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          snap_category: null,
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          snap_id: 'npm:@metamask/example-snap',
+          success: true,
+        },
+      });
+      snapController.destroy();
+    });
+
+    it('should not track event for disallowed handler', async () => {
+      const mockTrackEvent = jest.fn();
+      const rootMessenger = getControllerMessenger();
+
+      rootMessenger.registerActionHandler(
+        'PermissionController:getPermissions',
+        () => ({
+          [SnapEndowments.Cronjob]: {
+            caveats: [{ type: SnapCaveatType.SnapCronjob, value: '* * * * *' }],
+            date: 1664187844588,
+            id: 'izn0WGUO8cvq_jqvLQuQP',
+            invoker: MOCK_SNAP_ID,
+            parentCapability: SnapEndowments.Cronjob,
+          },
+        }),
+      );
+
+      const executionEnvironmentStub = new ExecutionEnvironmentStub(
+        getNodeEESMessenger(rootMessenger),
+      ) as unknown as NodeThreadExecutionService;
+
+      const [snapController] = getSnapControllerWithEES(
+        getSnapControllerWithEESOptions({
+          environmentEndowmentPermissions: ['endowment:cronjob'],
+          rootMessenger,
+          trackEvent: mockTrackEvent,
+          state: {
+            snaps: getPersistedSnapsState(),
+          },
+        }),
+        executionEnvironmentStub,
+      );
+
+      const snap = snapController.getExpect(MOCK_SNAP_ID);
+      await snapController.startSnap(snap.id);
+
+      await snapController.handleRequest({
+        snapId: snap.id,
+        origin: MOCK_ORIGIN,
+        handler: HandlerType.OnCronjob,
+        request: {
+          jsonrpc: '2.0',
+          method: 'test',
+          params: {},
+          id: 1,
+        },
+      });
+
+      expect(mockTrackEvent).not.toHaveBeenCalled();
+      snapController.destroy();
+    });
+  });
 });

packages/snaps-controllers/src/utils.test.ts

@@ -21,6 +21,7 @@ import {
   permissionsDiff,
   setDiff,
   throttleTracking,
+  TRACKABLE_HANDLERS,
 } from './utils';
 import { SnapEndowments } from '../../snaps-rpc-methods/src/endowments';
 
@@ -223,6 +224,29 @@ describe('debouncePersistState', () => {
   });
 });
 
+describe('TRACKABLE_HANDLERS', () => {
+  it('should contain the expected handler types', () => {
+    expect(TRACKABLE_HANDLERS).toStrictEqual([
+      HandlerType.OnHomePage,
+      HandlerType.OnInstall,
+      HandlerType.OnNameLookup,
+      HandlerType.OnRpcRequest,
+      HandlerType.OnSignature,
+      HandlerType.OnTransaction,
+      HandlerType.OnUpdate,
+    ]);
+  });
+
+  it('should be a readonly array', () => {
+    expect(Object.isFrozen(TRACKABLE_HANDLERS)).toBe(true);
+  });
+
+  it('should contain unique values', () => {
+    const uniqueValues = new Set(TRACKABLE_HANDLERS);
+    expect(uniqueValues.size).toBe(TRACKABLE_HANDLERS.length);
+  });
+});
+
 describe('throttleTracking', () => {
   beforeAll(() => {
     jest.useFakeTimers();

packages/snaps-controllers/src/utils.ts

@@ -380,15 +380,15 @@ export function debouncePersistState(
 /**
  * Handlers allowed for tracking.
  */
-export const TRACKABLE_HANDLERS = [
+export const TRACKABLE_HANDLERS = Object.freeze([
   HandlerType.OnHomePage,
   HandlerType.OnInstall,
   HandlerType.OnNameLookup,
   HandlerType.OnRpcRequest,
   HandlerType.OnSignature,
   HandlerType.OnTransaction,
   HandlerType.OnUpdate,
-] as const;
+] as const);
 
 /**
  * A union type representing all possible trackable handler types.