@rooguys/sdk 0.1.0 → 1.0.0

package/src/__tests__/property/request-construction.property.test.ts

@@ -1,6 +1,7 @@
 /**
  * Property-Based Test: HTTP Request Construction
  * Feature: sdk-testing-enhancement, Property 1: HTTP Request Construction
+ * Validates: Requirements 1.1, 3.1
  * 
  * Tests that any valid SDK method call constructs correct HTTP request
  * with proper method, URL, headers, and body structure.
@@ -8,20 +9,22 @@
 
 import fc from 'fast-check';
 import { Rooguys } from '../../index';
-import { createMockAxiosInstance } from '../utils/mockClient';
+import {
+  createMockRooguysClient,
+  mockAxiosResponse,
+  getLastRequestConfig,
+  MockAxiosInstance,
+} from '../utils/mockClient';
 import { arbitraries } from '../utils/generators';
-import axios from 'axios';
-
-// Mock axios
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
 
 describe('Property: HTTP Request Construction', () => {
-  let mockClient: any;
+  let client: Rooguys;
+  let mockAxios: MockAxiosInstance;
 
   beforeEach(() => {
-    mockClient = createMockAxiosInstance();
-    mockedAxios.create.mockReturnValue(mockClient);
+    const mock = createMockRooguysClient();
+    client = mock.client;
+    mockAxios = mock.mockAxios;
   });
 
   afterEach(() => {
@@ -31,32 +34,28 @@ describe('Property: HTTP Request Construction', () => {
   it('should construct valid POST request for event tracking', async () => {
     await fc.assert(
       fc.asyncProperty(
-        arbitraries.apiKey(),
         arbitraries.eventName(),
         arbitraries.userId(),
         arbitraries.properties(),
-        async (apiKey, eventName, userId, properties) => {
+        async (eventName, userId, properties) => {
           // Arrange
-          mockClient.post.mockResolvedValue({
-            data: { status: 'queued', message: 'Event accepted' }
-          });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            status: 'queued',
+            message: 'Event accepted'
+          }));
 
           // Act
-          await sdk.events.track(eventName, userId, properties);
+          await client.events.track(eventName, userId, properties);
 
           // Assert
-          expect(mockClient.post).toHaveBeenCalledWith(
-            '/event',
-            {
-              event_name: eventName,
-              user_id: userId,
-              properties,
-            },
-            expect.objectContaining({
-              params: expect.any(Object)
-            })
-          );
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('POST');
+          expect(config.url).toBe('/events');
+          expect(config.data).toEqual({
+            event_name: eventName,
+            user_id: userId,
+            properties,
+          });
         }
       ),
       { numRuns: 100 }
@@ -66,20 +65,21 @@ describe('Property: HTTP Request Construction', () => {
   it('should construct valid GET request for user profile', async () => {
     await fc.assert(
       fc.asyncProperty(
-        arbitraries.apiKey(),
         arbitraries.userId(),
-        async (apiKey, userId) => {
+        async (userId) => {
           // Arrange
-          mockClient.get.mockResolvedValue({
-            data: { user_id: userId, points: 100 }
-          });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            user_id: userId,
+            points: 100
+          }));
 
           // Act
-          await sdk.users.get(userId);
+          await client.users.get(userId);
 
           // Assert
-          expect(mockClient.get).toHaveBeenCalledWith(`/user/${encodeURIComponent(userId)}`);
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('GET');
+          expect(config.url).toBe(`/users/${encodeURIComponent(userId)}`);
         }
       ),
       { numRuns: 100 }
@@ -89,23 +89,21 @@ describe('Property: HTTP Request Construction', () => {
   it('should construct valid POST request for bulk user fetch', async () => {
     await fc.assert(
       fc.asyncProperty(
-        arbitraries.apiKey(),
         arbitraries.userIds(),
-        async (apiKey, userIds) => {
+        async (userIds) => {
           // Arrange
-          mockClient.post.mockResolvedValue({
-            data: { users: [] }
-          });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            users: []
+          }));
 
           // Act
-          await sdk.users.getBulk(userIds);
+          await client.users.getBulk(userIds);
 
           // Assert
-          expect(mockClient.post).toHaveBeenCalledWith(
-            '/users/bulk',
-            { user_ids: userIds }
-          );
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('POST');
+          expect(config.url).toBe('/users/bulk');
+          expect(config.data).toEqual({ user_ids: userIds });
         }
       ),
       { numRuns: 100 }
@@ -115,26 +113,29 @@ describe('Property: HTTP Request Construction', () => {
   it('should construct valid GET request with query parameters for leaderboard', async () => {
     await fc.assert(
       fc.asyncProperty(
-        arbitraries.apiKey(),
         arbitraries.timeframe(),
         arbitraries.pagination(),
-        async (apiKey, timeframe, { page, limit }) => {
+        async (timeframe, { page, limit }) => {
           // Arrange
-          mockClient.get.mockResolvedValue({
-            data: { rankings: [], page, limit, total: 0 }
-          });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            rankings: [],
+            page,
+            limit,
+            total: 0
+          }));
 
           // Act
-          await sdk.leaderboards.getGlobal(timeframe as any, page, limit);
+          await client.leaderboards.getGlobal(timeframe as any, page, limit);
 
           // Assert
-          expect(mockClient.get).toHaveBeenCalledWith(
-            '/leaderboard',
-            {
-              params: { timeframe, page, limit }
-            }
-          );
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('GET');
+          expect(config.url).toBe('/leaderboards/global');
+          expect(config.params).toEqual(expect.objectContaining({
+            timeframe,
+            page,
+            limit
+          }));
         }
       ),
       { numRuns: 100 }
@@ -144,57 +145,107 @@ describe('Property: HTTP Request Construction', () => {
   it('should construct valid POST request for Aha score declaration', async () => {
     await fc.assert(
       fc.asyncProperty(
-        arbitraries.apiKey(),
         arbitraries.userId(),
         arbitraries.ahaValue(),
-        async (apiKey, userId, value) => {
+        async (userId, value) => {
           // Arrange
-          mockClient.post.mockResolvedValue({
-            data: { success: true, message: 'Score declared' }
-          });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            success: true,
+            message: 'Score declared'
+          }));
 
           // Act
-          await sdk.aha.declare(userId, value);
+          await client.aha.declare(userId, value);
 
           // Assert
-          expect(mockClient.post).toHaveBeenCalledWith(
-            '/aha/declare',
-            {
-              user_id: userId,
-              value,
-            }
-          );
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('POST');
+          expect(config.url).toBe('/aha/declare');
+          expect(config.data).toEqual({
+            user_id: userId,
+            value,
+          });
         }
       ),
       { numRuns: 100 }
     );
   });
 
-  it('should include API key in request headers', async () => {
+  it('should construct valid GET request for badges list', async () => {
     await fc.assert(
       fc.asyncProperty(
-        arbitraries.apiKey(),
-        arbitraries.userId(),
-        async (apiKey, userId) => {
+        arbitraries.pagination(),
+        fc.boolean(),
+        async ({ page, limit }, activeOnly) => {
           // Arrange
-          mockClient.get.mockResolvedValue({
-            data: { user_id: userId, points: 100 }
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            badges: [],
+            pagination: { page, limit, total: 0, totalPages: 0 }
+          }));
+
+          // Act
+          await client.badges.list(page, limit, activeOnly);
+
+          // Assert
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('GET');
+          expect(config.url).toBe('/badges');
+          expect(config.params).toEqual({
+            page,
+            limit,
+            active_only: activeOnly
           });
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should construct valid GET request for levels list', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        arbitraries.pagination(),
+        async ({ page, limit }) => {
+          // Arrange
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            levels: [],
+            pagination: { page, limit, total: 0, totalPages: 0 }
+          }));
 
           // Act
-          const sdk = new Rooguys(apiKey);
-          await sdk.users.get(userId);
-
-          // Assert - verify axios.create was called with correct headers
-          expect(mockedAxios.create).toHaveBeenCalledWith(
-            expect.objectContaining({
-              headers: expect.objectContaining({
-                'x-api-key': apiKey,
-                'Content-Type': 'application/json',
-              })
-            })
-          );
+          await client.levels.list(page, limit);
+
+          // Assert
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('GET');
+          expect(config.url).toBe('/levels');
+          expect(config.params).toEqual({ page, limit });
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should construct valid GET request for questionnaire by slug', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        fc.string({ minLength: 1, maxLength: 50 }).filter(s => /^[a-z0-9-]+$/.test(s)),
+        async (slug) => {
+          // Arrange
+          mockAxios.request.mockResolvedValue(mockAxiosResponse({
+            id: 'q1',
+            slug,
+            title: 'Test',
+            questions: []
+          }));
+
+          // Act
+          await client.questionnaires.get(slug);
+
+          // Assert
+          const config = getLastRequestConfig(mockAxios);
+          expect(config.method).toBe('GET');
+          expect(config.url).toBe(`/questionnaires/${slug}`);
         }
       ),
       { numRuns: 100 }

package/src/__tests__/property/response-parsing.property.test.ts

@@ -1,6 +1,7 @@
 /**
- * Property-Based Test: Response Parsing Preservation
- * Feature: sdk-testing-enhancement, Property 2: Response Parsing Preservation
+ * Property-Based Test: Response Parsing Round-Trip
+ * Task 7.2: Property test for response parsing
+ * Validates: Requirements 2.1, 2.3, 2.4, 2.5
  * 
  * Tests that any successful response is parsed correctly and data structure
  * is preserved including nested objects, arrays, and null values.
@@ -8,19 +9,21 @@
 
 import fc from 'fast-check';
 import { Rooguys } from '../../index';
-import { createMockAxiosInstance } from '../utils/mockClient';
-import axios from 'axios';
+import { HttpClient } from '../../http-client';
+import {
+  createMockRooguysClient,
+  mockAxiosResponse,
+  MockAxiosInstance,
+} from '../utils/mockClient';
 
-// Mock axios
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('Property: Response Parsing Preservation', () => {
-  let mockClient: any;
+describe('Property: Response Parsing Round-Trip', () => {
+  let client: Rooguys;
+  let mockAxios: MockAxiosInstance;
 
   beforeEach(() => {
-    mockClient = createMockAxiosInstance();
-    mockedAxios.create.mockReturnValue(mockClient);
+    const mock = createMockRooguysClient();
+    client = mock.client;
+    mockAxios = mock.mockAxios;
   });
 
   afterEach(() => {
@@ -30,7 +33,6 @@ describe('Property: Response Parsing Preservation', () => {
   it('should preserve nested object structures in responses', async () => {
     await fc.assert(
       fc.asyncProperty(
-        fc.string({ minLength: 10, maxLength: 100 }),
         fc.string({ minLength: 1, maxLength: 255 }),
         fc.record({
           user_id: fc.string(),
@@ -47,16 +49,16 @@ describe('Property: Response Parsing Preservation', () => {
           }), { nil: null }),
           metrics: fc.dictionary(fc.string(), fc.integer()),
         }),
-        async (apiKey, userId, responseData) => {
+        async (userId, responseData) => {
           // Arrange
-          mockClient.get.mockResolvedValue({ data: responseData });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData));
 
           // Act
-          const result = await sdk.users.get(userId);
+          const result = await client.users.get(userId);
 
-          // Assert
-          expect(result).toEqual(responseData);
+          // Assert - SDK preserves the response structure
+          expect(result.user_id).toEqual(responseData.user_id);
+          expect(result.points).toEqual(responseData.points);
           expect(result.level).toEqual(responseData.level);
           expect(result.next_level).toEqual(responseData.next_level);
           expect(result.metrics).toEqual(responseData.metrics);
@@ -69,62 +71,63 @@ describe('Property: Response Parsing Preservation', () => {
   it('should preserve arrays in responses', async () => {
     await fc.assert(
       fc.asyncProperty(
-        fc.string({ minLength: 10, maxLength: 100 }),
         fc.array(fc.string({ minLength: 1, maxLength: 255 }), { minLength: 1, maxLength: 10 }),
         fc.array(fc.record({
           user_id: fc.string(),
           points: fc.integer(),
         }), { minLength: 0, maxLength: 20 }),
-        async (apiKey, userIds, usersData) => {
+        async (userIds, usersData) => {
           // Arrange
           const responseData = { users: usersData };
-          mockClient.post.mockResolvedValue({ data: responseData });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData));
 
           // Act
-          const result = await sdk.users.getBulk(userIds);
+          const result = await client.users.getBulk(userIds);
 
           // Assert
-          expect(result).toEqual(responseData);
           expect(Array.isArray(result.users)).toBe(true);
           expect(result.users).toHaveLength(usersData.length);
-          expect(result.users).toEqual(usersData);
+          result.users.forEach((user, index) => {
+            expect(user.user_id).toEqual(usersData[index].user_id);
+            expect(user.points).toEqual(usersData[index].points);
+          });
         }
       ),
       { numRuns: 100 }
     );
   });
 
-  it('should preserve null values in responses', async () => {
+  it('should preserve null values in aha score responses', async () => {
     await fc.assert(
       fc.asyncProperty(
-        fc.string({ minLength: 10, maxLength: 100 }),
         fc.string({ minLength: 1, maxLength: 255 }),
         fc.record({
           user_id: fc.string(),
+          current_score: fc.integer({ min: 0, max: 100 }),
           declarative_score: fc.option(fc.integer({ min: 1, max: 5 }), { nil: null }),
           inferred_score: fc.option(fc.integer({ min: 0, max: 100 }), { nil: null }),
+          status: fc.constantFrom('not_started', 'progressing', 'activated'),
           history: fc.record({
             initial: fc.option(fc.integer(), { nil: null }),
             initial_date: fc.option(fc.string(), { nil: null }),
             previous: fc.option(fc.integer(), { nil: null }),
           }),
         }),
-        async (apiKey, userId, responseData) => {
-          // Arrange
-          mockClient.get.mockResolvedValue({ data: responseData });
-          const sdk = new Rooguys(apiKey);
+        async (userId, ahaData) => {
+          // Arrange - mock the wrapped response { success: true, data: {...} }
+          const responseData = { success: true, data: ahaData };
+          mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData));
 
           // Act
-          const result = await sdk.aha.getUserScore(userId);
-
-          // Assert
-          expect(result).toEqual(responseData);
-          expect((result as any).declarative_score).toBe(responseData.declarative_score);
-          expect((result as any).inferred_score).toBe(responseData.inferred_score);
-          expect((result as any).history.initial).toBe(responseData.history.initial);
-          expect((result as any).history.initial_date).toBe(responseData.history.initial_date);
-          expect((result as any).history.previous).toBe(responseData.history.previous);
+          const result = await client.aha.getUserScore(userId);
+
+          // Assert - SDK unwraps { success: true, data: {...} } to just the data part
+          const data = result as any;
+          expect(data.declarative_score).toBe(ahaData.declarative_score);
+          expect(data.inferred_score).toBe(ahaData.inferred_score);
+          expect(data.history.initial).toBe(ahaData.history.initial);
+          expect(data.history.initial_date).toBe(ahaData.history.initial_date);
+          expect(data.history.previous).toBe(ahaData.history.previous);
         }
       ),
       { numRuns: 100 }
@@ -134,9 +137,8 @@ describe('Property: Response Parsing Preservation', () => {
   it('should handle empty objects and arrays', async () => {
     await fc.assert(
       fc.asyncProperty(
-        fc.string({ minLength: 10, maxLength: 100 }),
         fc.constantFrom('all-time', 'weekly', 'monthly'),
-        async (apiKey, timeframe) => {
+        async (timeframe) => {
           // Arrange
           const responseData = {
             timeframe,
@@ -145,53 +147,102 @@ describe('Property: Response Parsing Preservation', () => {
             total: 0,
             rankings: [],
           };
-          mockClient.get.mockResolvedValue({ data: responseData });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData));
 
           // Act
-          const result = await sdk.leaderboards.getGlobal(timeframe as any);
+          const result = await client.leaderboards.getGlobal(timeframe as any);
 
           // Assert
-          expect(result).toEqual(responseData);
           expect(Array.isArray(result.rankings)).toBe(true);
           expect(result.rankings).toHaveLength(0);
+          expect(result.timeframe).toBe(timeframe);
         }
       ),
       { numRuns: 100 }
     );
   });
 
-  it('should preserve complex nested structures', async () => {
+  it('should preserve complex nested structures with cache metadata', async () => {
     await fc.assert(
       fc.asyncProperty(
-        fc.string({ minLength: 10, maxLength: 100 }),
         fc.record({
-          success: fc.boolean(),
-          data: fc.record({
+          timeframe: fc.constantFrom('all-time', 'weekly', 'monthly'),
+          page: fc.integer({ min: 1, max: 100 }),
+          limit: fc.integer({ min: 1, max: 100 }),
+          total: fc.integer({ min: 0, max: 10000 }),
+          rankings: fc.array(fc.record({
+            rank: fc.integer({ min: 1, max: 1000 }),
             user_id: fc.string(),
-            current_score: fc.integer({ min: 0, max: 100 }),
-            declarative_score: fc.option(fc.integer({ min: 1, max: 5 }), { nil: null }),
-            inferred_score: fc.option(fc.integer({ min: 0, max: 100 }), { nil: null }),
-            status: fc.constantFrom('not_started', 'progressing', 'activated'),
-            history: fc.record({
-              initial: fc.option(fc.integer(), { nil: null }),
-              initial_date: fc.option(fc.string(), { nil: null }),
-              previous: fc.option(fc.integer(), { nil: null }),
-            }),
+            points: fc.integer({ min: 0, max: 100000 }),
+            percentile: fc.option(fc.float({ min: 0, max: 100 }), { nil: null }),
+          }), { minLength: 0, maxLength: 10 }),
+          cache_metadata: fc.option(fc.record({
+            cached_at: fc.string(),
+            ttl: fc.integer({ min: 0, max: 3600 }),
+          }), { nil: undefined }),
+        }),
+        async (responseData) => {
+          // Arrange
+          mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData));
+
+          // Act
+          const result = await client.leaderboards.getGlobal();
+
+          // Assert
+          expect(result.timeframe).toBe(responseData.timeframe);
+          expect(result.page).toBe(responseData.page);
+          expect(result.limit).toBe(responseData.limit);
+          expect(result.total).toBe(responseData.total);
+          expect(result.rankings).toHaveLength(responseData.rankings.length);
+          
+          // Verify each ranking entry
+          result.rankings.forEach((entry, index) => {
+            expect(entry.rank).toBe(responseData.rankings[index].rank);
+            expect(entry.user_id).toBe(responseData.rankings[index].user_id);
+            expect(entry.points).toBe(responseData.rankings[index].points);
+          });
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should preserve badge list structures', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        fc.record({
+          badges: fc.array(fc.record({
+            id: fc.string(),
+            name: fc.string(),
+            description: fc.option(fc.string(), { nil: null }),
+            icon_url: fc.option(fc.string(), { nil: null }),
+            is_active: fc.boolean(),
+          }), { minLength: 0, maxLength: 10 }),
+          pagination: fc.record({
+            page: fc.integer({ min: 1, max: 100 }),
+            limit: fc.integer({ min: 1, max: 100 }),
+            total: fc.integer({ min: 0, max: 1000 }),
+            totalPages: fc.integer({ min: 0, max: 100 }),
           }),
         }),
-        async (apiKey, responseData) => {
+        async (responseData) => {
           // Arrange
-          mockClient.get.mockResolvedValue({ data: responseData });
-          const sdk = new Rooguys(apiKey);
+          mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData));
 
           // Act
-          const result = await sdk.aha.getUserScore('test-user');
+          const result = await client.badges.list();
 
           // Assert
-          expect(result).toEqual(responseData);
-          expect(result.data).toEqual(responseData.data);
-          expect(result.data.history).toEqual(responseData.data.history);
+          expect(result.badges).toHaveLength(responseData.badges.length);
+          expect(result.pagination).toEqual(responseData.pagination);
+          
+          result.badges.forEach((badge, index) => {
+            expect(badge.id).toBe(responseData.badges[index].id);
+            expect(badge.name).toBe(responseData.badges[index].name);
+            expect(badge.description).toBe(responseData.badges[index].description);
+            expect(badge.icon_url).toBe(responseData.badges[index].icon_url);
+            expect(badge.is_active).toBe(responseData.badges[index].is_active);
+          });
         }
       ),
       { numRuns: 100 }