@rooguys/js 0.1.0 → 1.0.0

package/src/__tests__/unit/events.test.js

@@ -1,5 +1,6 @@
-import Rooguys from '../../index';
-import { mockSuccessResponse, mockErrorResponse, mockTimeoutError } from '../utils/mockClient';
+import { jest } from '@jest/globals';
+import Rooguys, { ValidationError } from '../../index';
+import { mockStandardizedSuccess, mockErrorResponse, mockTimeoutError } from '../utils/mockClient';
 import { mockResponses, mockErrors } from '../fixtures/responses';
 
 describe('Events Resource', () => {
@@ -14,7 +15,7 @@ describe('Events Resource', () => {
   describe('track', () => {
     it('should track an event with valid inputs', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       const result = await client.events.track('purchase_completed', 'user_123', {
@@ -22,7 +23,7 @@ describe('Events Resource', () => {
       });
 
       expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/event'),
+        expect.stringContaining('/events'),
         expect.objectContaining({
           method: 'POST',
           headers: expect.objectContaining({
@@ -41,7 +42,7 @@ describe('Events Resource', () => {
 
     it('should track an event with empty properties', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       const result = await client.events.track('user_login', 'user_456');
@@ -52,7 +53,7 @@ describe('Events Resource', () => {
 
     it('should include profile when includeProfile is true', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventWithProfileResponse)
+        mockStandardizedSuccess(mockResponses.trackEventWithProfileResponse)
       );
 
       const result = await client.events.track(
@@ -70,7 +71,7 @@ describe('Events Resource', () => {
 
     it('should handle special characters in event name', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       await client.events.track('user-signup_v2', 'user_123');
@@ -81,7 +82,7 @@ describe('Events Resource', () => {
 
     it('should handle special characters in user ID', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       await client.events.track('user_login', 'user@example.com');
@@ -92,7 +93,7 @@ describe('Events Resource', () => {
 
     it('should handle complex nested properties', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       const complexProperties = {
@@ -151,12 +152,12 @@ describe('Events Resource', () => {
 
       await expect(
         client.events.track('user_login', 'user_123')
-      ).rejects.toThrow('aborted');
+      ).rejects.toThrow('Request timeout');
     });
 
     it('should handle properties with null values', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       await client.events.track('user_updated', 'user_123', {
@@ -175,7 +176,7 @@ describe('Events Resource', () => {
 
     it('should handle properties with boolean values', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       await client.events.track('feature_toggled', 'user_123', {
@@ -189,7 +190,7 @@ describe('Events Resource', () => {
 
     it('should handle properties with numeric values', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       await client.events.track('score_updated', 'user_123', {
@@ -208,7 +209,7 @@ describe('Events Resource', () => {
 
     it('should handle empty string properties', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse(mockResponses.trackEventResponse)
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
       );
 
       await client.events.track('form_submitted', 'user_123', {
@@ -219,5 +220,243 @@ describe('Events Resource', () => {
       const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
       expect(callBody.properties.comment).toBe('');
     });
+
+    it('should include idempotency key header when provided', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('purchase_completed', 'user_123', { amount: 50 }, {
+        idempotencyKey: 'unique-key-123',
+      });
+
+      const callHeaders = global.fetch.mock.calls[0][1].headers;
+      expect(callHeaders['X-Idempotency-Key']).toBe('unique-key-123');
+    });
+
+    it('should include custom timestamp when provided', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
+      );
+
+      const timestamp = new Date(Date.now() - 24 * 60 * 60 * 1000); // 1 day ago
+      await client.events.track('historical_event', 'user_123', {}, {
+        timestamp,
+      });
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.timestamp).toBe(timestamp.toISOString());
+    });
+
+    it('should throw ValidationError when timestamp is more than 7 days old', async () => {
+      const oldTimestamp = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000); // 8 days ago
+
+      await expect(
+        client.events.track('old_event', 'user_123', {}, { timestamp: oldTimestamp })
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        client.events.track('old_event', 'user_123', {}, { timestamp: oldTimestamp })
+      ).rejects.toThrow('Custom timestamp cannot be more than 7 days in the past');
+    });
   });
+
+  describe('trackBatch', () => {
+    it('should track multiple events in a single request', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.batchTrackEventResponse)
+      );
+
+      const events = [
+        { eventName: 'event_1', userId: 'user_1', properties: { key: 'value1' } },
+        { eventName: 'event_2', userId: 'user_2', properties: { key: 'value2' } },
+      ];
+
+      const result = await client.events.trackBatch(events);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/events/batch'),
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({
+            events: [
+              { event_name: 'event_1', user_id: 'user_1', properties: { key: 'value1' } },
+              { event_name: 'event_2', user_id: 'user_2', properties: { key: 'value2' } },
+            ],
+          }),
+        })
+      );
+      expect(result).toEqual(mockResponses.batchTrackEventResponse);
+    });
+
+    it('should include idempotency key header when provided', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.batchTrackEventResponse)
+      );
+
+      const events = [
+        { eventName: 'event_1', userId: 'user_1' },
+      ];
+
+      await client.events.trackBatch(events, { idempotencyKey: 'batch-key-123' });
+
+      const callHeaders = global.fetch.mock.calls[0][1].headers;
+      expect(callHeaders['X-Idempotency-Key']).toBe('batch-key-123');
+    });
+
+    it('should throw ValidationError when events is not an array', async () => {
+      await expect(
+        client.events.trackBatch('not-an-array')
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        client.events.trackBatch('not-an-array')
+      ).rejects.toThrow('Events must be an array');
+    });
+
+    it('should throw ValidationError when events array is empty', async () => {
+      await expect(
+        client.events.trackBatch([])
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        client.events.trackBatch([])
+      ).rejects.toThrow('Events array cannot be empty');
+    });
+
+    it('should throw ValidationError when batch exceeds 100 events', async () => {
+      const events = Array.from({ length: 101 }, (_, i) => ({
+        eventName: `event_${i}`,
+        userId: `user_${i}`,
+      }));
+
+      await expect(
+        client.events.trackBatch(events)
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        client.events.trackBatch(events)
+      ).rejects.toThrow('Batch size exceeds maximum of 100 events');
+    });
+
+    it('should accept exactly 100 events', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess({ results: Array.from({ length: 100 }, (_, i) => ({ index: i, status: 'queued' })) })
+      );
+
+      const events = Array.from({ length: 100 }, (_, i) => ({
+        eventName: `event_${i}`,
+        userId: `user_${i}`,
+      }));
+
+      await expect(client.events.trackBatch(events)).resolves.toBeDefined();
+    });
+
+    it('should include custom timestamps in batch events', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.batchTrackEventResponse)
+      );
+
+      const timestamp = new Date(Date.now() - 24 * 60 * 60 * 1000); // 1 day ago
+      const events = [
+        { eventName: 'event_1', userId: 'user_1', timestamp },
+        { eventName: 'event_2', userId: 'user_2' },
+      ];
+
+      await client.events.trackBatch(events);
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.events[0].timestamp).toBe(timestamp.toISOString());
+      expect(callBody.events[1].timestamp).toBeUndefined();
+    });
+
+    it('should throw ValidationError when any batch event has timestamp older than 7 days', async () => {
+      const oldTimestamp = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000); // 8 days ago
+      const events = [
+        { eventName: 'event_1', userId: 'user_1' },
+        { eventName: 'event_2', userId: 'user_2', timestamp: oldTimestamp },
+      ];
+
+      await expect(
+        client.events.trackBatch(events)
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        client.events.trackBatch(events)
+      ).rejects.toThrow('Event at index 1: Custom timestamp cannot be more than 7 days in the past');
+    });
+
+    it('should handle batch response with mixed results', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.batchTrackEventWithErrorResponse)
+      );
+
+      const events = [
+        { eventName: 'event_1', userId: 'user_1' },
+        { eventName: '', userId: 'user_2' },
+        { eventName: 'event_3', userId: 'user_3' },
+      ];
+
+      const result = await client.events.trackBatch(events);
+
+      expect(result.results[0].status).toBe('queued');
+      expect(result.results[1].status).toBe('error');
+      expect(result.results[1].error).toBe('Invalid event name');
+      expect(result.results[2].status).toBe('queued');
+    });
+
+    it('should handle events with empty properties', async () => {
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.batchTrackEventResponse)
+      );
+
+      const events = [
+        { eventName: 'event_1', userId: 'user_1' },
+        { eventName: 'event_2', userId: 'user_2', properties: {} },
+      ];
+
+      await client.events.trackBatch(events);
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.events[0].properties).toEqual({});
+      expect(callBody.events[1].properties).toEqual({});
+    });
+  });
+
+  describe('trackLegacy (deprecated)', () => {
+    it('should log deprecation warning when called', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
+      );
+
+      await client.events.trackLegacy('user_login', 'user_123');
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('DEPRECATION WARNING')
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('/v1/event')
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('should use the legacy /event endpoint', async () => {
+      jest.spyOn(console, 'warn').mockImplementation(() => {});
+      global.fetch.mockResolvedValue(
+        mockStandardizedSuccess(mockResponses.trackEventResponse)
+      );
+
+      await client.events.trackLegacy('user_login', 'user_123');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/event'),
+        expect.any(Object)
+      );
+      // Should NOT contain /events (plural)
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).not.toContain('/events');
+    });
+  });
+
 });

package/src/__tests__/unit/leaderboards.test.js

@@ -43,6 +43,93 @@ describe('Leaderboards Resource', () => {
       expect(callUrl).toContain('limit=25');
     });
 
+    it('should support options object signature', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getGlobal({
+        timeframe: 'weekly',
+        page: 2,
+        limit: 25,
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('timeframe=weekly');
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=25');
+    });
+
+    it('should filter by persona', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getGlobal({
+        persona: 'Achiever',
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('persona=Achiever');
+    });
+
+    it('should filter by level range', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getGlobal({
+        minLevel: 2,
+        maxLevel: 5,
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('min_level=2');
+      expect(callUrl).toContain('max_level=5');
+    });
+
+    it('should filter by date range with Date objects', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      const startDate = new Date('2024-01-01T00:00:00Z');
+      const endDate = new Date('2024-01-31T23:59:59Z');
+
+      await client.leaderboards.getGlobal({
+        startDate,
+        endDate,
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('start_date=2024-01-01T00%3A00%3A00.000Z');
+      expect(callUrl).toContain('end_date=2024-01-31T23%3A59%3A59.000Z');
+    });
+
+    it('should filter by date range with ISO strings', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getGlobal({
+        startDate: '2024-01-01T00:00:00Z',
+        endDate: '2024-01-31T23:59:59Z',
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('start_date=');
+      expect(callUrl).toContain('end_date=');
+    });
+
+    it('should parse cache metadata in response', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      const result = await client.leaderboards.getGlobal();
+
+      expect(result.cacheMetadata).toBeDefined();
+      expect(result.cacheMetadata.cachedAt).toBeInstanceOf(Date);
+      expect(result.cacheMetadata.ttl).toBe(300);
+    });
+
+    it('should include percentile in rankings', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      const result = await client.leaderboards.getGlobal();
+
+      expect(result.rankings[0].percentile).toBe(99.5);
+      expect(result.rankings[1].percentile).toBe(98.0);
+    });
+
     it('should throw error for invalid timeframe', async () => {
       global.fetch.mockResolvedValue(
         mockErrorResponse(400, mockErrors.invalidTimeframeError.message)
@@ -52,6 +139,20 @@ describe('Leaderboards Resource', () => {
         'Timeframe must be one of'
       );
     });
+
+    it('should support combined filters with legacy signature', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getGlobal('weekly', 1, 50, {
+        persona: 'Explorer',
+        minLevel: 3,
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('timeframe=weekly');
+      expect(callUrl).toContain('persona=Explorer');
+      expect(callUrl).toContain('min_level=3');
+    });
   });
 
   describe('list', () => {
@@ -72,6 +173,21 @@ describe('Leaderboards Resource', () => {
       const callUrl = global.fetch.mock.calls[0][0];
       expect(callUrl).toContain('search=top');
     });
+
+    it('should support options object signature', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardsListResponse));
+
+      await client.leaderboards.list({
+        page: 2,
+        limit: 25,
+        search: 'weekly',
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=25');
+      expect(callUrl).toContain('search=weekly');
+    });
   });
 
   describe('getCustom', () => {
@@ -84,6 +200,48 @@ describe('Leaderboards Resource', () => {
       expect(result.rankings).toBeDefined();
     });
 
+    it('should support options object signature with filters', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getCustom('lb1', {
+        page: 2,
+        limit: 25,
+        persona: 'Competitor',
+        minLevel: 1,
+        maxLevel: 10,
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('/leaderboards/lb1');
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=25');
+      expect(callUrl).toContain('persona=Competitor');
+      expect(callUrl).toContain('min_level=1');
+      expect(callUrl).toContain('max_level=10');
+    });
+
+    it('should filter by date range', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getCustom('lb1', {
+        startDate: new Date('2024-01-01'),
+        endDate: new Date('2024-01-31'),
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('start_date=');
+      expect(callUrl).toContain('end_date=');
+    });
+
+    it('should parse cache metadata', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      const result = await client.leaderboards.getCustom('lb1');
+
+      expect(result.cacheMetadata).toBeDefined();
+      expect(result.cacheMetadata.cachedAt).toBeInstanceOf(Date);
+    });
+
     it('should throw 404 for non-existent leaderboard', async () => {
       global.fetch.mockResolvedValue(mockErrorResponse(404, 'Leaderboard not found'));
 
@@ -91,6 +249,18 @@ describe('Leaderboards Resource', () => {
         'Leaderboard not found'
       );
     });
+
+    it('should support legacy signature with additional options', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardWithFiltersResponse));
+
+      await client.leaderboards.getCustom('lb1', 1, 50, 'search', {
+        persona: 'Achiever',
+      });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('search=search');
+      expect(callUrl).toContain('persona=Achiever');
+    });
   });
 
   describe('getUserRank', () => {
@@ -102,6 +272,23 @@ describe('Leaderboards Resource', () => {
       expect(result.rank).toBe(42);
     });
 
+    it('should include percentile in response', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankWithPercentileResponse));
+
+      const result = await client.leaderboards.getUserRank('lb1', 'user_123');
+
+      expect(result.rank).toBe(42);
+      expect(result.percentile).toBe(95.8);
+    });
+
+    it('should return null percentile when not available', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankResponse));
+
+      const result = await client.leaderboards.getUserRank('lb1', 'user_123');
+
+      expect(result.percentile).toBeNull();
+    });
+
     it('should throw 404 for non-existent user or leaderboard', async () => {
       global.fetch.mockResolvedValue(mockErrorResponse(404, 'Not found'));
 
@@ -110,4 +297,66 @@ describe('Leaderboards Resource', () => {
       ).rejects.toThrow('Not found');
     });
   });
+
+  describe('getAroundUser', () => {
+    it('should get leaderboard entries around user with default range', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.aroundUserResponse));
+
+      const result = await client.leaderboards.getAroundUser('lb1', 'user123');
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('/leaderboards/lb1/users/user123/around');
+      expect(callUrl).toContain('range=5');
+      expect(result.rankings).toHaveLength(5);
+      expect(result.user).toBeDefined();
+      expect(result.user.rank).toBe(42);
+    });
+
+    it('should get leaderboard entries around user with custom range', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.aroundUserResponse));
+
+      await client.leaderboards.getAroundUser('lb1', 'user123', 10);
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('range=10');
+    });
+
+    it('should include percentile for all entries', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.aroundUserResponse));
+
+      const result = await client.leaderboards.getAroundUser('lb1', 'user123');
+
+      result.rankings.forEach(entry => {
+        expect(entry.percentile).toBeDefined();
+        expect(typeof entry.percentile).toBe('number');
+      });
+    });
+
+    it('should parse cache metadata', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.aroundUserResponse));
+
+      const result = await client.leaderboards.getAroundUser('lb1', 'user123');
+
+      expect(result.cacheMetadata).toBeDefined();
+      expect(result.cacheMetadata.cachedAt).toBeInstanceOf(Date);
+      expect(result.cacheMetadata.ttl).toBe(60);
+    });
+
+    it('should URL encode user ID', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.aroundUserResponse));
+
+      await client.leaderboards.getAroundUser('lb1', 'user@example.com');
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('user%40example.com');
+    });
+
+    it('should throw 404 for non-existent user', async () => {
+      global.fetch.mockResolvedValue(mockErrorResponse(404, 'User not found'));
+
+      await expect(
+        client.leaderboards.getAroundUser('lb1', 'invalid_user')
+      ).rejects.toThrow('User not found');
+    });
+  });
 });

package/src/__tests__/unit/questionnaires.test.js

@@ -1,5 +1,5 @@
 import Rooguys from '../../index';
-import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockStandardizedSuccess, mockErrorResponse } from '../utils/mockClient';
 import { mockResponses } from '../fixtures/responses';
 
 describe('Questionnaires Resource', () => {
@@ -13,12 +13,12 @@ describe('Questionnaires Resource', () => {
 
   describe('get', () => {
     it('should get questionnaire by slug', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.questionnaireResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.questionnaireResponse));
 
       const result = await client.questionnaires.get('user-persona');
 
       expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/questionnaire/user-persona'),
+        expect.stringContaining('/questionnaires/user-persona'),
         expect.any(Object)
       );
       expect(result.slug).toBe('user-persona');
@@ -33,7 +33,7 @@ describe('Questionnaires Resource', () => {
     });
 
     it('should handle questionnaire with multiple questions', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.questionnaireResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.questionnaireResponse));
 
       const result = await client.questionnaires.get('user-persona');
 
@@ -44,12 +44,12 @@ describe('Questionnaires Resource', () => {
 
   describe('getActive', () => {
     it('should get active questionnaire', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.questionnaireResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.questionnaireResponse));
 
       const result = await client.questionnaires.getActive();
 
       expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/questionnaire/active'),
+        expect.stringContaining('/questionnaires/active'),
         expect.any(Object)
       );
       expect(result.is_active).toBe(true);