add tests for custom events

Author: fadi-george

__mocks__/react-native.ts

@@ -86,6 +86,7 @@ const mockRNOneSignal = {
   addOutcomeWithValue: vi.fn(),
   displayNotification: vi.fn(),
   preventDefault: vi.fn(),
+  trackEvent: vi.fn(),
 };
 
 const mockPlatform = {

src/helpers.test.ts

@@ -1,6 +1,10 @@
 import type { NativeModule } from 'react-native';
 import type { MockInstance } from 'vitest';
-import { isNativeModuleLoaded, isValidCallback } from './helpers';
+import {
+  isNativeModuleLoaded,
+  isObjectSerializable,
+  isValidCallback,
+} from './helpers';
 
 describe('helpers', () => {
   let errorSpy: MockInstance;
@@ -58,4 +62,42 @@ describe('helpers', () => {
       expect(result).toBe(true);
     });
   });
+
+  describe('isObjectSerializable', () => {
+    test.each([
+      { description: 'an empty object', value: {} },
+      { description: 'an object with string values', value: { key: 'value' } },
+      { description: 'an object with number values', value: { count: 42 } },
+      { description: 'an object with boolean values', value: { active: true } },
+      { description: 'an object with null values', value: { data: null } },
+      {
+        description: 'a nested object',
+        value: { outer: { inner: 'value' } },
+      },
+      {
+        description: 'an object with array values',
+        value: { items: [1, 2, 3] },
+      },
+    ])('should return true for $description', ({ value }) => {
+      expect(isObjectSerializable(value)).toBe(true);
+    });
+
+    test.each([
+      { description: 'null', value: null },
+      { description: 'undefined', value: undefined },
+      { description: 'a string', value: 'string' },
+      { description: 'a number', value: 123 },
+      { description: 'a boolean', value: true },
+      { description: 'an array', value: [1, 2, 3] },
+      { description: 'a function', value: () => {} },
+    ])('should return false for $description', ({ value }) => {
+      expect(isObjectSerializable(value)).toBe(false);
+    });
+
+    test('should return false for objects with circular references', () => {
+      const circular: Record<string, unknown> = {};
+      circular.self = circular;
+      expect(isObjectSerializable(circular)).toBe(false);
+    });
+  });
 });

src/helpers.ts

@@ -16,3 +16,18 @@ export function isNativeModuleLoaded(module: NativeModule): boolean {
 
   return true;
 }
+
+/**
+ * Returns true if the value is a JSON-serializable object.
+ */
+export function isObjectSerializable(value: unknown): boolean {
+  if (!(typeof value === 'object' && value !== null && !Array.isArray(value))) {
+    return false;
+  }
+  try {
+    JSON.stringify(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

src/index.test.ts

@@ -894,6 +894,49 @@ describe('OneSignal', () => {
       });
     });
 
+    describe('trackEvent', () => {
+      test('should track event with name and properties', () => {
+        const properties = { key: 'value', count: 42 };
+        OneSignal.User.trackEvent('purchase', properties);
+        expect(mockRNOneSignal.trackEvent).toHaveBeenCalledWith(
+          'purchase',
+          properties,
+        );
+      });
+
+      test('should track event with just name using default empty properties', () => {
+        OneSignal.User.trackEvent('page_view');
+        expect(mockRNOneSignal.trackEvent).toHaveBeenCalledWith('page_view', {});
+      });
+
+      test('should not track event if native module is not loaded', () => {
+        isNativeLoadedSpy.mockReturnValue(false);
+        OneSignal.User.trackEvent('event');
+        expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled();
+      });
+
+      test('should not track event if properties are not serializable', () => {
+        const circular: Record<string, unknown> = {};
+        circular.self = circular;
+        OneSignal.User.trackEvent('event', circular);
+        expect(errorSpy).toHaveBeenCalledWith(
+          'Properties must be a JSON-serializable object',
+        );
+        expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled();
+      });
+
+      test('should not track event if properties is not an object', () => {
+        OneSignal.User.trackEvent(
+          'event',
+          'invalid' as unknown as Record<string, unknown>,
+        );
+        expect(errorSpy).toHaveBeenCalledWith(
+          'Properties must be a JSON-serializable object',
+        );
+        expect(mockRNOneSignal.trackEvent).not.toHaveBeenCalled();
+      });
+    });
+
     describe('Notifications', () => {
       describe('hasPermission (deprecated)', () => {
         test('should log deprecation warning', () => {

src/index.ts

@@ -14,7 +14,11 @@ import {
 import type { OSNotificationPermission } from './constants/subscription';
 import EventManager from './events/EventManager';
 import NotificationWillDisplayEvent from './events/NotificationWillDisplayEvent';
-import { isNativeModuleLoaded, isValidCallback } from './helpers';
+import {
+  isNativeModuleLoaded,
+  isObjectSerializable,
+  isValidCallback,
+} from './helpers';
 import type {
   InAppMessage,
   InAppMessageClickEvent,
@@ -602,7 +606,7 @@ export namespace OneSignal {
       if (!isNativeModuleLoaded(RNOneSignal)) return;
 
       if (!isObjectSerializable(properties)) {
-        console.error('Properties must be JSON-serializable');
+        console.error('Properties must be a JSON-serializable object');
         return;
       }
 
@@ -956,21 +960,6 @@ export namespace OneSignal {
   }
 }
 
-/**
- * Returns true if the value is a JSON-serializable object.
- */
-function isObjectSerializable(value: unknown): boolean {
-  if (!(typeof value === 'object' && value !== null && !Array.isArray(value))) {
-    return false;
-  }
-  try {
-    JSON.stringify(value);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
 export { OSNotificationPermission } from './constants/subscription';
 export {
   NotificationWillDisplayEvent,