test(SDK-518): add mechanical coverage ratchet for models, enums, and utils

Author: jferrao-itrbl

.gitignore

@@ -99,4 +99,5 @@ docs/
 .agent/
 .claude/
 .cursor/
+.opencode/
 .pi/

src/__tests__/index.test.tsx

@@ -95,4 +95,116 @@ describe('public SDK surface', () => {
     expect(useAppStateListener).toBeDefined();
     expect(useDeviceOrientation).toBeDefined();
   });
+
+  describe('exported enum values', () => {
+    it('IterableActionSource contains expected members', () => {
+      expect(IterableActionSource.push).toBe(0);
+      expect(IterableActionSource.appLink).toBe(1);
+      expect(IterableActionSource.inApp).toBe(2);
+      expect(IterableActionSource.embedded).toBe(3);
+    });
+
+    it('IterableInAppCloseSource contains expected members', () => {
+      expect(IterableInAppCloseSource.back).toBe(0);
+      expect(IterableInAppCloseSource.link).toBe(1);
+      expect(IterableInAppCloseSource.unknown).toBe(100);
+    });
+
+    it('IterableInAppLocation contains expected members', () => {
+      expect(IterableInAppLocation.inApp).toBe(0);
+      expect(IterableInAppLocation.inbox).toBe(1);
+    });
+
+    it('IterableInAppShowResponse contains expected members', () => {
+      expect(IterableInAppShowResponse.show).toBe(0);
+      expect(IterableInAppShowResponse.skip).toBe(1);
+    });
+
+    it('IterableInAppTriggerType contains expected members', () => {
+      expect(IterableInAppTriggerType.immediate).toBe(0);
+      expect(IterableInAppTriggerType.event).toBe(1);
+      expect(IterableInAppTriggerType.never).toBe(2);
+    });
+
+    it('IterableDataRegion contains expected members', () => {
+      expect(IterableDataRegion.US).toBe(0);
+      expect(IterableDataRegion.EU).toBe(1);
+    });
+
+    it('IterableLogLevel contains expected members', () => {
+      expect(IterableLogLevel.error).toBe(3);
+      expect(IterableLogLevel.debug).toBe(1);
+      expect(IterableLogLevel.info).toBe(2);
+    });
+
+    it('IterablePushPlatform contains expected members', () => {
+      expect(IterablePushPlatform.sandbox).toBe(0);
+      expect(IterablePushPlatform.production).toBe(1);
+      expect(IterablePushPlatform.auto).toBe(2);
+    });
+
+    it('IterableRetryBackoff contains expected members', () => {
+      expect(IterableRetryBackoff.linear).toBe('LINEAR');
+      expect(IterableRetryBackoff.exponential).toBe('EXPONENTIAL');
+    });
+
+    it('IterableEmbeddedViewType contains expected members', () => {
+      expect(IterableEmbeddedViewType.Banner).toBe(0);
+      expect(IterableEmbeddedViewType.Card).toBe(1);
+      expect(IterableEmbeddedViewType.Notification).toBe(2);
+    });
+  });
+
+  describe('exported hooks are functions', () => {
+    it('useAppStateListener is a function', () => {
+      expect(typeof useAppStateListener).toBe('function');
+    });
+
+    it('useDeviceOrientation is a function', () => {
+      expect(typeof useDeviceOrientation).toBe('function');
+    });
+  });
+
+  describe('exported components are valid React components', () => {
+    it('IterableInbox is a valid React component', () => {
+      expect(IterableInbox).toBeDefined();
+      // React components are functions or classes (forwardRef objects expose a render fn)
+      const type = typeof IterableInbox;
+      expect(
+        type === 'function' ||
+        type === 'object' ||
+        type === 'symbol'
+      ).toBe(true);
+    });
+
+    it('IterableInboxEmptyState is a valid React component', () => {
+      expect(IterableInboxEmptyState).toBeDefined();
+      const type = typeof IterableInboxEmptyState;
+      expect(
+        type === 'function' ||
+        type === 'object' ||
+        type === 'symbol'
+      ).toBe(true);
+    });
+
+    it('IterableInboxMessageCell is a valid React component', () => {
+      expect(IterableInboxMessageCell).toBeDefined();
+      const type = typeof IterableInboxMessageCell;
+      expect(
+        type === 'function' ||
+        type === 'object' ||
+        type === 'symbol'
+      ).toBe(true);
+    });
+
+    it('IterableEmbeddedView is a valid React component', () => {
+      expect(IterableEmbeddedView).toBeDefined();
+      const type = typeof IterableEmbeddedView;
+      expect(
+        type === 'function' ||
+        type === 'object' ||
+        type === 'symbol'
+      ).toBe(true);
+    });
+  });
 });

src/core/classes/IterableAction.test.ts

@@ -0,0 +1,68 @@
+import { IterableAction } from './IterableAction';
+
+describe('IterableAction', () => {
+  describe('constructor', () => {
+    it('creates an instance with type only', () => {
+      const action = new IterableAction('openUrl');
+      expect(action.type).toBe('openUrl');
+      expect(action.data).toBeUndefined();
+      expect(action.userInput).toBeUndefined();
+    });
+
+    it('creates an instance with type, data, and userInput', () => {
+      const action = new IterableAction('openUrl', 'https://example.com', 'tap');
+      expect(action.type).toBe('openUrl');
+      expect(action.data).toBe('https://example.com');
+      expect(action.userInput).toBe('tap');
+    });
+  });
+
+  describe('fromDict', () => {
+    it('copies all fields when present', () => {
+      const dict = new IterableAction('openUrl', 'https://example.com', 'tap');
+      const action = IterableAction.fromDict(dict);
+      expect(action.type).toBe('openUrl');
+      expect(action.data).toBe('https://example.com');
+      expect(action.userInput).toBe('tap');
+    });
+
+    it('handles missing data and userInput', () => {
+      // Simulate a payload where only type is defined — data and userInput are absent.
+      const dict = {
+        type: 'openUrl',
+      } as IterableAction;
+
+      const action = IterableAction.fromDict(dict);
+
+      expect(action.type).toBe('openUrl');
+      expect(action.data).toBeUndefined();
+      expect(action.userInput).toBeUndefined();
+    });
+
+    it('handles only data missing', () => {
+      const dict = {
+        type: 'openUrl',
+        userInput: 'tap',
+      } as IterableAction;
+
+      const action = IterableAction.fromDict(dict);
+
+      expect(action.type).toBe('openUrl');
+      expect(action.data).toBeUndefined();
+      expect(action.userInput).toBe('tap');
+    });
+
+    it('handles only userInput missing', () => {
+      const dict = {
+        type: 'openUrl',
+        data: 'https://example.com',
+      } as IterableAction;
+
+      const action = IterableAction.fromDict(dict);
+
+      expect(action.type).toBe('openUrl');
+      expect(action.data).toBe('https://example.com');
+      expect(action.userInput).toBeUndefined();
+    });
+  });
+});

src/core/classes/IterableActionContext.test.ts

@@ -0,0 +1,60 @@
+import { IterableAction } from './IterableAction';
+import { IterableActionContext } from './IterableActionContext';
+import { IterableActionSource } from '../enums/IterableActionSource';
+
+describe('IterableActionContext', () => {
+  describe('constructor', () => {
+    it('creates an instance with action and source', () => {
+      const action = new IterableAction('openUrl', 'https://example.com');
+      const context = new IterableActionContext(action, IterableActionSource.push);
+
+      expect(context.action).toBe(action);
+      expect(context.source).toBe(IterableActionSource.push);
+    });
+  });
+
+  describe('fromDict', () => {
+    it('creates a full instance from a complete dict', () => {
+      const dict = new IterableActionContext(
+        new IterableAction('openUrl', 'https://example.com', 'tap'),
+        IterableActionSource.inApp
+      );
+
+      const context = IterableActionContext.fromDict(dict);
+
+      expect(context.source).toBe(IterableActionSource.inApp);
+      expect(context.action.type).toBe('openUrl');
+      expect(context.action.data).toBe('https://example.com');
+      expect(context.action.userInput).toBe('tap');
+    });
+
+    it('handles a partial action dict with only type', () => {
+      // Simulate a payload where the nested action only has `type` defined.
+      const dict = {
+        action: { type: 'openUrl' } as IterableAction,
+        source: IterableActionSource.appLink,
+      } as IterableActionContext;
+
+      const context = IterableActionContext.fromDict(dict);
+
+      expect(context.source).toBe(IterableActionSource.appLink);
+      expect(context.action.type).toBe('openUrl');
+      expect(context.action.data).toBeUndefined();
+      expect(context.action.userInput).toBeUndefined();
+    });
+
+    it('handles a partial action dict with type and data only', () => {
+      const dict = {
+        action: { type: 'openUrl', data: 'https://example.com' } as IterableAction,
+        source: IterableActionSource.embedded,
+      } as IterableActionContext;
+
+      const context = IterableActionContext.fromDict(dict);
+
+      expect(context.source).toBe(IterableActionSource.embedded);
+      expect(context.action.type).toBe('openUrl');
+      expect(context.action.data).toBe('https://example.com');
+      expect(context.action.userInput).toBeUndefined();
+    });
+  });
+});

src/core/enums/IterableDataRegion.test.ts

@@ -0,0 +1,8 @@
+import { IterableDataRegion } from './IterableDataRegion';
+
+describe('IterableDataRegion', () => {
+  it('contains the expected members', () => {
+    expect(IterableDataRegion.US).toBe(0);
+    expect(IterableDataRegion.EU).toBe(1);
+  });
+});

src/core/enums/IterableLogLevel.test.ts

@@ -0,0 +1,9 @@
+import { IterableLogLevel } from './IterableLogLevel';
+
+describe('IterableLogLevel', () => {
+  it('contains the expected members', () => {
+    expect(IterableLogLevel.error).toBe(3);
+    expect(IterableLogLevel.debug).toBe(1);
+    expect(IterableLogLevel.info).toBe(2);
+  });
+});

src/core/enums/IterablePushPlatform.test.ts

@@ -0,0 +1,9 @@
+import { IterablePushPlatform } from './IterablePushPlatform';
+
+describe('IterablePushPlatform', () => {
+  it('contains the expected members', () => {
+    expect(IterablePushPlatform.sandbox).toBe(0);
+    expect(IterablePushPlatform.production).toBe(1);
+    expect(IterablePushPlatform.auto).toBe(2);
+  });
+});

src/core/enums/IterableRetryBackoff.test.ts

@@ -0,0 +1,8 @@
+import { IterableRetryBackoff } from './IterableRetryBackoff';
+
+describe('IterableRetryBackoff', () => {
+  it('contains the expected members', () => {
+    expect(IterableRetryBackoff.linear).toBe('LINEAR');
+    expect(IterableRetryBackoff.exponential).toBe('EXPONENTIAL');
+  });
+});