@rooguys/sdk 0.1.0

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

@@ -0,0 +1,200 @@
+/**
+ * Property-Based Test: Response Parsing Preservation
+ * Feature: sdk-testing-enhancement, Property 2: Response Parsing Preservation
+ * 
+ * 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 { Rooguys } from '../../index';
+import { createMockAxiosInstance } from '../utils/mockClient';
+import axios from 'axios';
+
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Property: Response Parsing Preservation', () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    mockClient = createMockAxiosInstance();
+    mockedAxios.create.mockReturnValue(mockClient);
+  });
+
+  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
+          mockClient.get.mockResolvedValue({ data: 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 };
+          mockClient.post.mockResolvedValue({ data: 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
+          mockClient.get.mockResolvedValue({ data: responseData });
+          const sdk = new Rooguys(apiKey);
+
+          // 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);
+        }
+      ),
+      { 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: [],
+          };
+          mockClient.get.mockResolvedValue({ data: responseData });
+          const sdk = new Rooguys(apiKey);
+
+          // Act
+          const result = await sdk.leaderboards.getGlobal(timeframe as any);
+
+          // 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
+          mockClient.get.mockResolvedValue({ data: 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__/unit/aha.test.ts

@@ -0,0 +1,164 @@
+import { Rooguys } from '../../index';
+import { createMockAxiosInstance } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+describe('Aha Resource', () => {
+  let client: Rooguys;
+  let mockAxios: any;
+
+  beforeEach(() => {
+    mockAxios = createMockAxiosInstance();
+    client = new Rooguys('test-api-key');
+    (client as any).client = mockAxios;
+  });
+
+  describe('declare', () => {
+    it('should declare aha score with valid value', async () => {
+      mockAxios.post.mockResolvedValue({ data: mockResponses.ahaDeclarationResponse });
+
+      const result = await client.aha.declare('user123', 4);
+
+      expect(mockAxios.post).toHaveBeenCalledWith('/aha/declare', {
+        user_id: 'user123',
+        value: 4,
+      });
+      expect(result).toEqual(mockResponses.ahaDeclarationResponse);
+    });
+
+    it('should declare aha score with value 1', async () => {
+      mockAxios.post.mockResolvedValue({ data: mockResponses.ahaDeclarationResponse });
+
+      const result = await client.aha.declare('user123', 1);
+
+      expect(mockAxios.post).toHaveBeenCalledWith('/aha/declare', {
+        user_id: 'user123',
+        value: 1,
+      });
+      expect(result).toEqual(mockResponses.ahaDeclarationResponse);
+    });
+
+    it('should declare aha score with value 5', async () => {
+      mockAxios.post.mockResolvedValue({ data: mockResponses.ahaDeclarationResponse });
+
+      const result = await client.aha.declare('user123', 5);
+
+      expect(mockAxios.post).toHaveBeenCalledWith('/aha/declare', {
+        user_id: 'user123',
+        value: 5,
+      });
+      expect(result).toEqual(mockResponses.ahaDeclarationResponse);
+    });
+
+    it('should throw error for value 0', async () => {
+      await expect(client.aha.declare('user123', 0)).rejects.toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+      expect(mockAxios.post).not.toHaveBeenCalled();
+    });
+
+    it('should throw error for value 6', async () => {
+      await expect(client.aha.declare('user123', 6)).rejects.toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+      expect(mockAxios.post).not.toHaveBeenCalled();
+    });
+
+    it('should throw error for negative value', async () => {
+      await expect(client.aha.declare('user123', -1)).rejects.toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+      expect(mockAxios.post).not.toHaveBeenCalled();
+    });
+
+    it('should throw error for non-integer value', async () => {
+      await expect(client.aha.declare('user123', 3.5)).rejects.toThrow(
+        'Aha score value must be an integer between 1 and 5'
+      );
+      expect(mockAxios.post).not.toHaveBeenCalled();
+    });
+
+    it('should handle API error response', async () => {
+      mockAxios.post.mockRejectedValue({
+        isAxiosError: true,
+        response: {
+          data: mockErrors.ahaValueError,
+        },
+      });
+
+      await expect(client.aha.declare('user123', 3)).rejects.toThrow();
+    });
+  });
+
+  describe('getUserScore', () => {
+    it('should get user aha score successfully', async () => {
+      mockAxios.get.mockResolvedValue({ data: mockResponses.ahaScoreResponse });
+
+      const result = await client.aha.getUserScore('user123');
+
+      expect(mockAxios.get).toHaveBeenCalledWith('/users/user123/aha');
+      expect(result).toEqual(mockResponses.ahaScoreResponse);
+    });
+
+    it('should parse all aha score fields correctly', async () => {
+      mockAxios.get.mockResolvedValue({ data: 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 () => {
+      mockAxios.get.mockResolvedValue({ data: 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 () => {
+      mockAxios.get.mockRejectedValue({
+        isAxiosError: true,
+        response: {
+          status: 404,
+          data: 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,
+          },
+        },
+      };
+      mockAxios.get.mockResolvedValue({ data: 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();
+    });
+  });
+});

package/src/__tests__/unit/badges.test.ts

@@ -0,0 +1,112 @@
+import axios from 'axios';
+import { Rooguys } from '../../index';
+import { createMockAxiosInstance, mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Badges Resource', () => {
+  let client: Rooguys;
+  let mockAxiosInstance: ReturnType<typeof createMockAxiosInstance>;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    mockAxiosInstance = createMockAxiosInstance();
+    mockedAxios.create.mockReturnValue(mockAxiosInstance as any);
+    client = new Rooguys(apiKey);
+    jest.clearAllMocks();
+  });
+
+  describe('list', () => {
+    it('should list badges with default parameters', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.badgesListResponse)
+      );
+
+      const result = await client.badges.list();
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/badges', {
+        params: { page: 1, limit: 50, active_only: false },
+      });
+      expect(result).toEqual(mockResponses.badgesListResponse);
+      expect(result.badges).toHaveLength(1);
+    });
+
+    it('should list badges with custom pagination', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.badgesListResponse)
+      );
+
+      await client.badges.list(2, 25);
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/badges', {
+        params: { page: 2, limit: 25, active_only: false },
+      });
+    });
+
+    it('should list only active badges', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.badgesListResponse)
+      );
+
+      await client.badges.list(1, 50, true);
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/badges', {
+        params: { page: 1, limit: 50, active_only: true },
+      });
+    });
+
+    it('should handle empty badge list', async () => {
+      const emptyResponse = {
+        badges: [],
+        pagination: {
+          page: 1,
+          limit: 50,
+          total: 0,
+          totalPages: 0,
+        },
+      };
+      mockAxiosInstance.get.mockResolvedValue(mockSuccessResponse(emptyResponse));
+
+      const result = await client.badges.list();
+
+      expect(result.badges).toEqual([]);
+      expect(result.pagination.total).toBe(0);
+    });
+
+    it('should throw error for invalid pagination', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(400, mockErrors.invalidPaginationError.message)
+      );
+
+      await expect(client.badges.list(1, 150)).rejects.toThrow(
+        'Limit must be between 1 and 100'
+      );
+    });
+
+    it('should handle badges with all fields', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.badgesListResponse)
+      );
+
+      const result = await client.badges.list();
+
+      const badge = result.badges[0];
+      expect(badge.id).toBeDefined();
+      expect(badge.name).toBeDefined();
+      expect(badge.description).toBeDefined();
+      expect(badge.icon_url).toBeDefined();
+      expect(badge.is_active).toBeDefined();
+      expect(badge.unlock_criteria).toBeDefined();
+    });
+
+    it('should handle server error', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(500, 'Internal server error')
+      );
+
+      await expect(client.badges.list()).rejects.toThrow('Internal server error');
+    });
+  });
+});

package/src/__tests__/unit/config.test.ts

@@ -0,0 +1,187 @@
+import axios from 'axios';
+import { Rooguys } from '../../index';
+import { createMockAxiosInstance } from '../utils/mockClient';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('SDK Configuration', () => {
+  let mockAxiosInstance: ReturnType<typeof createMockAxiosInstance>;
+
+  beforeEach(() => {
+    mockAxiosInstance = createMockAxiosInstance();
+    mockedAxios.create.mockReturnValue(mockAxiosInstance as any);
+    jest.clearAllMocks();
+  });
+
+  describe('initialization', () => {
+    it('should initialize with API key', () => {
+      const client = new Rooguys('test-api-key');
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'x-api-key': 'test-api-key',
+          }),
+        })
+      );
+    });
+
+    it('should use default base URL when not provided', () => {
+      new Rooguys('test-api-key');
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'https://api.rooguys.com/v1',
+        })
+      );
+    });
+
+    it('should use custom base URL when provided', () => {
+      new Rooguys('test-api-key', {
+        baseUrl: 'https://custom.api.com/v1',
+      });
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'https://custom.api.com/v1',
+        })
+      );
+    });
+
+    it('should use default timeout when not provided', () => {
+      new Rooguys('test-api-key');
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timeout: 10000,
+        })
+      );
+    });
+
+    it('should use custom timeout when provided', () => {
+      new Rooguys('test-api-key', {
+        timeout: 30000,
+      });
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timeout: 30000,
+        })
+      );
+    });
+
+    it('should set Content-Type header', () => {
+      new Rooguys('test-api-key');
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+          }),
+        })
+      );
+    });
+
+    it('should accept both baseUrl and timeout options', () => {
+      new Rooguys('test-api-key', {
+        baseUrl: 'https://staging.api.com/v1',
+        timeout: 20000,
+      });
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'https://staging.api.com/v1',
+          timeout: 20000,
+        })
+      );
+    });
+
+    it('should handle empty options object', () => {
+      new Rooguys('test-api-key', {});
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'https://api.rooguys.com/v1',
+          timeout: 10000,
+        })
+      );
+    });
+
+    it('should handle localhost base URL', () => {
+      new Rooguys('test-api-key', {
+        baseUrl: 'http://localhost:3001/v1',
+      });
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'http://localhost:3001/v1',
+        })
+      );
+    });
+
+    it('should handle very short timeout', () => {
+      new Rooguys('test-api-key', {
+        timeout: 1000,
+      });
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timeout: 1000,
+        })
+      );
+    });
+
+    it('should handle very long timeout', () => {
+      new Rooguys('test-api-key', {
+        timeout: 60000,
+      });
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timeout: 60000,
+        })
+      );
+    });
+  });
+
+  describe('API key handling', () => {
+    it('should include API key in all requests', () => {
+      new Rooguys('my-secret-key');
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'x-api-key': 'my-secret-key',
+          }),
+        })
+      );
+    });
+
+    it('should handle long API keys', () => {
+      const longKey = 'sk_live_' + 'a'.repeat(100);
+      new Rooguys(longKey);
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'x-api-key': longKey,
+          }),
+        })
+      );
+    });
+
+    it('should handle API keys with special characters', () => {
+      const keyWithSpecialChars = 'sk_test_abc-123_XYZ.456';
+      new Rooguys(keyWithSpecialChars);
+
+      expect(mockedAxios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'x-api-key': keyWithSpecialChars,
+          }),
+        })
+      );
+    });
+  });
+});