@rooguys/js 0.1.0

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

@@ -0,0 +1,211 @@
+/**
+ * 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.
+ */
+
+import fc from 'fast-check';
+import { jest } from '@jest/globals';
+import Rooguys from '../../index.js';
+import { createMockFetch } from '../utils/mockClient.js';
+import { arbitraries } from '../utils/generators.js';
+
+describe('Property: HTTP Request Construction', () => {
+  let mockFetch;
+
+  beforeEach(() => {
+    mockFetch = createMockFetch();
+    global.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  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) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ status: 'queued', message: 'Event accepted' })
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          await sdk.events.track(eventName, userId, properties);
+
+          // Assert
+          expect(mockFetch).toHaveBeenCalledTimes(1);
+          const callArgs = mockFetch.mock.calls[0];
+          expect(callArgs[0]).toContain('/event');
+          expect(callArgs[1].method).toBe('POST');
+          const body = JSON.parse(callArgs[1].body);
+          expect(body.event_name).toBe(eventName);
+          expect(body.user_id).toBe(userId);
+          expect(body.properties).toEqual(properties);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should construct valid GET request for user profile', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        arbitraries.apiKey(),
+        arbitraries.userId(),
+        async (apiKey, userId) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ user_id: userId, points: 100 })
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          await sdk.users.get(userId);
+
+          // Assert
+          expect(mockFetch).toHaveBeenCalledTimes(1);
+          const callArgs = mockFetch.mock.calls[0];
+          expect(callArgs[0]).toContain(`/user/${encodeURIComponent(userId)}`);
+          expect(callArgs[1].method).toBe('GET');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should construct valid POST request for bulk user fetch', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        arbitraries.apiKey(),
+        arbitraries.userIds(),
+        async (apiKey, userIds) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ users: [] })
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          await sdk.users.getBulk(userIds);
+
+          // Assert
+          expect(mockFetch).toHaveBeenCalledTimes(1);
+          const callArgs = mockFetch.mock.calls[0];
+          expect(callArgs[0]).toContain('/users/bulk');
+          expect(callArgs[1].method).toBe('POST');
+          const body = JSON.parse(callArgs[1].body);
+          expect(body.user_ids).toEqual(userIds);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  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 }) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ rankings: [], page, limit, total: 0 })
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          await sdk.leaderboards.getGlobal(timeframe, page, limit);
+
+          // Assert
+          expect(mockFetch).toHaveBeenCalledTimes(1);
+          const callArgs = mockFetch.mock.calls[0];
+          const url = new URL(callArgs[0]);
+          expect(url.pathname).toContain('/leaderboard');
+          expect(url.searchParams.get('timeframe')).toBe(timeframe);
+          expect(url.searchParams.get('page')).toBe(String(page));
+          expect(url.searchParams.get('limit')).toBe(String(limit));
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  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) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ success: true, message: 'Score declared' })
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          await sdk.aha.declare(userId, value);
+
+          // Assert
+          expect(mockFetch).toHaveBeenCalledTimes(1);
+          const callArgs = mockFetch.mock.calls[0];
+          expect(callArgs[0]).toContain('/aha/declare');
+          expect(callArgs[1].method).toBe('POST');
+          const body = JSON.parse(callArgs[1].body);
+          expect(body.user_id).toBe(userId);
+          expect(body.value).toBe(value);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should include API key in request headers', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        arbitraries.apiKey(),
+        arbitraries.userId(),
+        async (apiKey, userId) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ user_id: userId, points: 100 })
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          await sdk.users.get(userId);
+
+          // Assert
+          expect(mockFetch).toHaveBeenCalledTimes(1);
+          const callArgs = mockFetch.mock.calls[0];
+          expect(callArgs[1].headers['x-api-key']).toBe(apiKey);
+          expect(callArgs[1].headers['Content-Type']).toBe('application/json');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});

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

@@ -0,0 +1,217 @@
+/**
+ * Property-Based Test: Response Parsing Preservation
+ * Feature: sdk-testing-enhancement, Property 2: Response Parsing Preservation
+ * Validates: Requirements 1.2, 7.1, 7.2, 7.3, 7.4
+ * 
+ * Tests that any successful response is parsed correctly and data structure
+ * is preserved including nested objects, arrays, and null values.
+ */
+
+import fc from 'fast-check';
+import { jest } from '@jest/globals';
+import Rooguys from '../../index.js';
+import { createMockFetch } from '../utils/mockClient.js';
+
+describe('Property: Response Parsing Preservation', () => {
+  let mockFetch;
+
+  beforeEach(() => {
+    mockFetch = createMockFetch();
+    global.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  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(),
+          points: fc.integer(),
+          level: fc.record({
+            id: fc.string(),
+            name: fc.string(),
+            level_number: fc.integer(),
+          }),
+          next_level: fc.option(fc.record({
+            id: fc.string(),
+            name: fc.string(),
+            points_required: fc.integer(),
+          }), { nil: null }),
+          metrics: fc.dictionary(fc.string(), fc.integer()),
+        }),
+        async (apiKey, userId, responseData) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => responseData
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          const result = await sdk.users.get(userId);
+
+          // Assert
+          expect(result).toEqual(responseData);
+          expect(result.level).toEqual(responseData.level);
+          expect(result.next_level).toEqual(responseData.next_level);
+          expect(result.metrics).toEqual(responseData.metrics);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  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) => {
+          // Arrange
+          const responseData = { users: usersData };
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => responseData
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          const result = await sdk.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);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should preserve null values 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(),
+          declarative_score: fc.option(fc.integer({ min: 1, max: 5 }), { nil: null }),
+          inferred_score: fc.option(fc.integer({ min: 0, max: 100 }), { nil: null }),
+          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
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => responseData
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          const result = await sdk.aha.getUserScore(userId);
+
+          // Assert
+          expect(result).toEqual(responseData);
+          expect(result.declarative_score).toBe(responseData.declarative_score);
+          expect(result.inferred_score).toBe(responseData.inferred_score);
+          expect(result.history.initial).toBe(responseData.history.initial);
+          expect(result.history.initial_date).toBe(responseData.history.initial_date);
+          expect(result.history.previous).toBe(responseData.history.previous);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  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) => {
+          // Arrange
+          const responseData = {
+            timeframe,
+            page: 1,
+            limit: 50,
+            total: 0,
+            rankings: [],
+          };
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => responseData
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          const result = await sdk.leaderboards.getGlobal(timeframe);
+
+          // Assert
+          expect(result).toEqual(responseData);
+          expect(Array.isArray(result.rankings)).toBe(true);
+          expect(result.rankings).toHaveLength(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('should preserve complex nested structures', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        fc.string({ minLength: 10, maxLength: 100 }),
+        fc.record({
+          success: fc.boolean(),
+          data: 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, responseData) => {
+          // Arrange
+          mockFetch.mockClear();
+          mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => responseData
+          });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          const result = await sdk.aha.getUserScore('test-user');
+
+          // Assert
+          expect(result).toEqual(responseData);
+          expect(result.data).toEqual(responseData.data);
+          expect(result.data.history).toEqual(responseData.data.history);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});

package/src/__tests__/setup.js

@@ -0,0 +1,25 @@
+/**
+ * Jest setup file for browser SDK tests
+ */
+import { jest } from '@jest/globals';
+
+// Setup fetch mock
+global.fetch = jest.fn();
+
+// Setup AbortController for timeout tests
+global.AbortController = class AbortController {
+  constructor() {
+    this.signal = {
+      aborted: false,
+    };
+  }
+  
+  abort() {
+    this.signal.aborted = true;
+  }
+};
+
+// Reset mocks after each test
+afterEach(() => {
+  jest.clearAllMocks();
+});

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

@@ -0,0 +1,191 @@
+import { jest } from '@jest/globals';
+import Rooguys from '../../index.js';
+import { mockResponses, mockErrors } from '../fixtures/responses.js';
+
+describe('Aha Resource', () => {
+  let client;
+  let originalFetch;
+
+  beforeEach(() => {
+    client = new Rooguys('test-api-key');
+    originalFetch = global.fetch;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  describe('declare', () => {
+    it('should declare aha score with valid value', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => mockResponses.ahaDeclarationResponse,
+      });
+
+      const result = await client.aha.declare('user123', 4);
+
+      expect(global.fetch).toHaveBeenCalled();
+      const callArgs = global.fetch.mock.calls[0];
+      expect(callArgs[0]).toContain('/aha/declare');
+      expect(JSON.parse(callArgs[1].body)).toEqual({
+        user_id: 'user123',
+        value: 4,
+      });
+      expect(result).toEqual(mockResponses.ahaDeclarationResponse);
+    });
+
+    it('should declare aha score with value 1', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => mockResponses.ahaDeclarationResponse,
+      });
+
+      const result = await client.aha.declare('user123', 1);
+
+      expect(global.fetch).toHaveBeenCalled();
+      const callArgs = global.fetch.mock.calls[0];
+      expect(JSON.parse(callArgs[1].body)).toEqual({
+        user_id: 'user123',
+        value: 1,
+      });
+      expect(result).toEqual(mockResponses.ahaDeclarationResponse);
+    });
+
+    it('should declare aha score with value 5', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => mockResponses.ahaDeclarationResponse,
+      });
+
+      const result = await client.aha.declare('user123', 5);
+
+      expect(global.fetch).toHaveBeenCalled();
+      const callArgs = global.fetch.mock.calls[0];
+      expect(JSON.parse(callArgs[1].body)).toEqual({
+        user_id: 'user123',
+        value: 5,
+      });
+      expect(result).toEqual(mockResponses.ahaDeclarationResponse);
+    });
+
+    it('should throw error for value 0', () => {
+      expect(() => client.aha.declare('user123', 0)).toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+    });
+
+    it('should throw error for value 6', () => {
+      expect(() => client.aha.declare('user123', 6)).toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+    });
+
+    it('should throw error for negative value', () => {
+      expect(() => client.aha.declare('user123', -1)).toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+    });
+
+    it('should throw error for non-integer value', () => {
+      expect(() => client.aha.declare('user123', 3.5)).toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+    });
+
+    it('should handle API error response', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        statusText: 'Bad Request',
+        json: async () => mockErrors.ahaValueError,
+      });
+
+      await expect(client.aha.declare('user123', 3)).rejects.toThrow();
+    });
+  });
+
+  describe('getUserScore', () => {
+    it('should get user aha score successfully', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => mockResponses.ahaScoreResponse,
+      });
+
+      const result = await client.aha.getUserScore('user123');
+
+      expect(global.fetch).toHaveBeenCalled();
+      const callArgs = global.fetch.mock.calls[0];
+      expect(callArgs[0]).toContain('/users/user123/aha');
+      expect(result).toEqual(mockResponses.ahaScoreResponse);
+    });
+
+    it('should parse all aha score fields correctly', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => mockResponses.ahaScoreResponse,
+      });
+
+      const result = await client.aha.getUserScore('user123');
+
+      expect(result.success).toBe(true);
+      expect(result.data.user_id).toBe('user123');
+      expect(result.data.current_score).toBe(75);
+      expect(result.data.declarative_score).toBe(80);
+      expect(result.data.inferred_score).toBe(70);
+      expect(result.data.status).toBe('activated');
+    });
+
+    it('should preserve history structure', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => mockResponses.ahaScoreResponse,
+      });
+
+      const result = await client.aha.getUserScore('user123');
+
+      expect(result.data.history).toEqual({
+        initial: 50,
+        initial_date: '2024-01-01T00:00:00Z',
+        previous: 70,
+      });
+    });
+
+    it('should handle 404 error when user not found', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        json: async () => mockErrors.notFoundError,
+      });
+
+      await expect(client.aha.getUserScore('nonexistent')).rejects.toThrow();
+    });
+
+    it('should handle null declarative and inferred scores', async () => {
+      const responseWithNulls = {
+        success: true,
+        data: {
+          user_id: 'user123',
+          current_score: 0,
+          declarative_score: null,
+          inferred_score: null,
+          status: 'not_started',
+          history: {
+            initial: null,
+            initial_date: null,
+            previous: null,
+          },
+        },
+      };
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => responseWithNulls,
+      });
+
+      const result = await client.aha.getUserScore('user123');
+
+      expect(result.data.declarative_score).toBeNull();
+      expect(result.data.inferred_score).toBeNull();
+      expect(result.data.history.initial).toBeNull();
+    });
+  });
+});