add tests for custom events

Author: fadi-george

__test__/support/helpers/requests.ts

@@ -325,3 +325,16 @@ export const setUpdateUserError = ({
     status,
     retryAfter,
   });
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// custom events
+const getCustomEventsUri = () =>
+  `**/apps/${APP_ID}/integrations/sdk/custom_events`;
+export const sendCustomEventFn = vi.fn();
+export const setSendCustomEventResponse = () =>
+  getHandler({
+    uri: getCustomEventsUri(),
+    method: 'post',
+    status: 200,
+    callback: sendCustomEventFn,
+  });

src/core/CoreModule.ts

@@ -1,5 +1,6 @@
 import { logMethodCall } from 'src/shared/utils/utils';
 import { CustomEventController } from './controllers/CustomEventController';
+import { CustomEventsOperationExecutor } from './executors/CustomEventOperationExecutor';
 import { IdentityOperationExecutor } from './executors/IdentityOperationExecutor';
 import { LoginUserOperationExecutor } from './executors/LoginUserOperationExecutor';
 import { RefreshUserOperationExecutor } from './executors/RefreshUserOperationExecutor';
@@ -119,13 +120,15 @@ export default class CoreModule {
       this.rebuildUserService,
       this.newRecordsState,
     );
+    const customEventOpExecutor = new CustomEventsOperationExecutor();
 
     return [
       identityOpExecutor,
       loginOpExecutor,
       refreshOpExecutor,
       subscriptionOpExecutor,
       updateSubOpExecutor,
+      customEventOpExecutor,
     ];
   }
 }

src/core/controllers/CustomEventController.ts

@@ -23,7 +23,7 @@ export class CustomEventController implements ICustomEventController {
       appId,
       onesignalId: identityModel.onesignalId,
       externalId: identityModel.externalId,
-      timestamp: Date.now(),
+      timestamp: new Date().toISOString(),
       event,
     });
 

src/core/executors/CustomEventOperationExecutor.ts

@@ -54,7 +54,7 @@ export class CustomEventsOperationExecutor implements IOperationExecutor {
         external_id: operation.externalId,
         timestamp: operation.timestamp,
         payload: {
-          ...operation.event.properties,
+          ...(operation.event.properties ?? {}),
           os_sdk: this.eventMetadata,
         },
       },

src/core/requestService/RequestService.ts

@@ -276,7 +276,9 @@ export class RequestService {
     const { appId } = requestMetadata;
     return OneSignalApiBase.post(
       `apps/${appId}/integrations/sdk/custom_events`,
-      [event],
+      {
+        events: [event],
+      },
       requestMetadata.jwtHeader,
     );
   }

src/core/types/customEvents.ts

@@ -1,6 +1,6 @@
 export interface ICustomEvent {
   name: string;
-  properties: Record<string, unknown>;
+  properties?: Record<string, unknown>;
 }
 
 export interface ICustomEventController {

src/onesignal/OneSignal.test.ts

@@ -19,13 +19,15 @@ import {
   getUserFn,
   mockPageStylesCss,
   mockServerConfig,
+  sendCustomEventFn,
   setAddAliasError,
   setAddAliasResponse,
   setCreateSubscriptionResponse,
   setCreateUserResponse,
   setDeleteAliasResponse,
   setDeleteSubscriptionResponse,
   setGetUserResponse,
+  setSendCustomEventResponse,
   setTransferSubscriptionResponse,
   setUpdateUserResponse,
   transferSubscriptionFn,
@@ -935,6 +937,39 @@ describe('OneSignal', () => {
     });
   });
 
+  describe('Custom Events', () => {
+    test('can send a custom event', async () => {
+      setSendCustomEventResponse();
+
+      const name = 'test_event';
+      const properties = {
+        test_property: 'test_value',
+      };
+
+      window.OneSignal.User.trackEvent(name, properties);
+
+      await vi.waitUntil(() => sendCustomEventFn.mock.calls.length === 1);
+
+      expect(sendCustomEventFn).toHaveBeenCalledWith({
+        events: [
+          {
+            name,
+            onesignal_id: DUMMY_ONESIGNAL_ID,
+            payload: {
+              os_sdk: {
+                sdk: '1',
+                device_model: '',
+                device_os: 56,
+              },
+              test_property: 'test_value',
+            },
+            timestamp: expect.any(String),
+          },
+        ],
+      });
+    });
+  });
+
   test('should preserve operations order without needing await', async () => {
     await setupSubModelStore({
       id: DUMMY_SUBSCRIPTION_ID,

src/onesignal/User.ts

@@ -12,8 +12,8 @@ import {
 } from '../shared/errors/InvalidArgumentError';
 import {
   isObject,
+  isObjectSerializable,
   isValidEmail,
-  isValidJsonObject,
   logMethodCall,
 } from '../shared/utils/utils';
 
@@ -282,17 +282,17 @@ export default class User {
     return OneSignal.coreDirector.getPropertiesModel().language;
   }
 
-  public trackEvent(name: string, properties?: Record<string, unknown>) {
-    if (!isValidJsonObject(properties)) {
+  public trackEvent(name: string, properties: Record<string, unknown> = {}) {
+    if (!isObjectSerializable(properties)) {
       return Log.error(
         'Custom event properties must be a JSON-serializable object',
       );
     }
 
     logMethodCall('trackEvent', { name, properties });
-    OneSignal.coreDirector.customEventController.sendCustomEvent(
+    OneSignal.coreDirector.customEventController.sendCustomEvent({
       name,
       properties,
-    );
+    });
   }
 }

src/onesignal/UserNamespace.test.ts

@@ -2,13 +2,15 @@ import {
   DUMMY_ONESIGNAL_ID,
   DUMMY_PUSH_TOKEN,
 } from '__test__/support/constants';
+import Log from 'src/shared/libraries/Log';
 import { IDManager } from 'src/shared/managers/IDManager';
 import { TestEnvironment } from '../../__test__/support/environment/TestEnvironment';
 import UserChangeEvent from '../page/models/UserChangeEvent';
 import { Subscription } from '../shared/models/Subscription';
+import User from './User';
 import UserNamespace from './UserNamespace';
 
-vi.mock('../shared/libraries/Log');
+const errorSpy = vi.spyOn(Log, 'error').mockImplementation(() => '');
 
 describe('UserNamespace', () => {
   let userNamespace: UserNamespace;
@@ -427,4 +429,32 @@ describe('UserNamespace', () => {
       expect(customNamespace.PushSubscription).toBeDefined();
     });
   });
+
+  describe('Custom Events', () => {
+    test('should call track event', () => {
+      const trackEventSpy = vi.spyOn(User.prototype, 'trackEvent');
+      const name = 'test_event';
+      const properties = {
+        test_property: 'test_value',
+      };
+
+      // should validate properties
+      // @ts-expect-error - mock invalid argument
+      userNamespace.trackEvent(name, 123);
+      expect(errorSpy).toHaveBeenCalledWith(
+        'Custom event properties must be a JSON-serializable object',
+      );
+
+      // big ints can't be serialized
+      userNamespace.trackEvent(name, {
+        data: 10n,
+      });
+      expect(errorSpy).toHaveBeenCalledWith(
+        'Custom event properties must be a JSON-serializable object',
+      );
+
+      userNamespace.trackEvent(name, properties);
+      expect(trackEventSpy).toHaveBeenCalledWith(name, properties);
+    });
+  });
 });

src/shared/utils/utils.ts

@@ -332,7 +332,11 @@ export function isObject(value: unknown) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-export function isValidJsonObject(value: unknown): boolean {
+/**
+ * Returns true if the value is a JSON-serializable object.
+ */
+export function isObjectSerializable(value: unknown): boolean {
+  if (!isObject(value)) return false;
   try {
     JSON.stringify(value);
     return true;