@rooguys/sdk 0.1.0

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

@@ -0,0 +1,220 @@
+import axios from 'axios';
+import { Rooguys } from '../../index';
+import { createMockAxiosInstance, mockErrorResponse } from '../utils/mockClient';
+import { mockErrors } from '../fixtures/responses';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Error Handling', () => {
+  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('4xx client errors', () => {
+    it('should throw error with message for 400 Bad Request', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(400, 'Bad Request')
+      );
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Bad Request'
+      );
+    });
+
+    it('should throw error with message for 401 Unauthorized', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(401, mockErrors.unauthorizedError.message)
+      );
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'Invalid or missing API key'
+      );
+    });
+
+    it('should throw error with message for 404 Not Found', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(404, mockErrors.notFoundError.message)
+      );
+
+      await expect(client.users.get('nonexistent')).rejects.toThrow(
+        "User 'user123' does not exist in this project"
+      );
+    });
+
+    it('should include validation details in error', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(400, 'Validation failed', mockErrors.validationError.details)
+      );
+
+      await expect(client.events.track('', 'user1')).rejects.toThrow(
+        'Validation failed'
+      );
+    });
+
+    it('should throw error for 429 Too Many Requests', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(429, 'Rate limit exceeded')
+      );
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'Rate limit exceeded'
+      );
+    });
+  });
+
+  describe('5xx server errors', () => {
+    it('should throw error with message for 500 Internal Server Error', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(500, 'Internal server error')
+      );
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Internal server error'
+      );
+    });
+
+    it('should throw error with message for 503 Service Unavailable', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(503, mockErrors.queueFullError.message)
+      );
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Event queue is full'
+      );
+    });
+
+    it('should throw error for 502 Bad Gateway', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(502, 'Bad Gateway')
+      );
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'Bad Gateway'
+      );
+    });
+  });
+
+  describe('network errors', () => {
+    it('should throw error for network timeout', async () => {
+      const timeoutError = new Error('timeout of 10000ms exceeded');
+      (timeoutError as any).code = 'ECONNABORTED';
+      mockAxiosInstance.post.mockRejectedValue(timeoutError);
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'timeout'
+      );
+    });
+
+    it('should throw error for connection refused', async () => {
+      const connectionError = new Error('connect ECONNREFUSED');
+      (connectionError as any).code = 'ECONNREFUSED';
+      mockAxiosInstance.get.mockRejectedValue(connectionError);
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'ECONNREFUSED'
+      );
+    });
+
+    it('should throw error for DNS lookup failure', async () => {
+      const dnsError = new Error('getaddrinfo ENOTFOUND');
+      (dnsError as any).code = 'ENOTFOUND';
+      mockAxiosInstance.get.mockRejectedValue(dnsError);
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'ENOTFOUND'
+      );
+    });
+  });
+
+  describe('malformed responses', () => {
+    it('should handle response without error message', async () => {
+      const error: any = new Error('Request failed');
+      error.response = {
+        status: 500,
+        data: {},
+      };
+      error.isAxiosError = true;
+      mockAxiosInstance.post.mockRejectedValue(error);
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Request failed'
+      );
+    });
+
+    it('should handle response with null data', async () => {
+      const error: any = new Error('Request failed');
+      error.response = {
+        status: 500,
+        data: null,
+      };
+      error.isAxiosError = true;
+      mockAxiosInstance.get.mockRejectedValue(error);
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'Request failed'
+      );
+    });
+  });
+
+  describe('error detail preservation', () => {
+    it('should preserve error details from API response', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(400, 'Validation failed', [
+          { field: 'user_id', message: 'User ID is required' },
+          { field: 'event_name', message: 'Event name is required' },
+        ])
+      );
+
+      try {
+        await client.events.track('', '');
+        fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toContain('Validation failed');
+      }
+    });
+
+    it('should handle errors with nested details', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(400, 'Complex validation error', {
+          errors: {
+            properties: {
+              amount: 'Must be a positive number',
+            },
+          },
+        })
+      );
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Complex validation error'
+      );
+    });
+  });
+
+  describe('non-axios errors', () => {
+    it('should rethrow non-axios errors', async () => {
+      const customError = new Error('Custom error');
+      mockAxiosInstance.post.mockRejectedValue(customError);
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Custom error'
+      );
+    });
+
+    it('should handle TypeError', async () => {
+      const typeError = new TypeError('Cannot read property');
+      mockAxiosInstance.get.mockRejectedValue(typeError);
+
+      await expect(client.users.get('user1')).rejects.toThrow(
+        'Cannot read property'
+      );
+    });
+  });
+});

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

@@ -0,0 +1,282 @@
+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('Events 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('track', () => {
+    it('should track an event with valid inputs', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      const result = await client.events.track('purchase-completed', 'user_123', {
+        amount: 50.0,
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        {
+          event_name: 'purchase-completed',
+          user_id: 'user_123',
+          properties: { amount: 50.0 },
+        },
+        { params: { include_profile: undefined } }
+      );
+      expect(result).toEqual(mockResponses.trackEventResponse);
+    });
+
+    it('should track an event with empty properties', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      const result = await client.events.track('user-login', 'user_456');
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        {
+          event_name: 'user-login',
+          user_id: 'user_456',
+          properties: {},
+        },
+        { params: { include_profile: undefined } }
+      );
+      expect(result).toEqual(mockResponses.trackEventResponse);
+    });
+
+    it('should include profile when includeProfile is true', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventWithProfileResponse)
+      );
+
+      const result = await client.events.track(
+        'purchase-completed',
+        'user_123',
+        { amount: 50.0 },
+        { includeProfile: true }
+      );
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        {
+          event_name: 'purchase-completed',
+          user_id: 'user_123',
+          properties: { amount: 50.0 },
+        },
+        { params: { include_profile: true } }
+      );
+      expect(result).toEqual(mockResponses.trackEventWithProfileResponse);
+      expect(result.profile).toBeDefined();
+    });
+
+    it('should handle special characters in event name', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('user-signup_v2', 'user_123');
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          event_name: 'user-signup_v2',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle special characters in user ID', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('user-login', 'user@example.com');
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          user_id: 'user@example.com',
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle complex nested properties', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      const complexProperties = {
+        order: {
+          id: 'order_123',
+          items: [
+            { sku: 'ITEM1', quantity: 2 },
+            { sku: 'ITEM2', quantity: 1 },
+          ],
+          total: 150.0,
+        },
+        metadata: {
+          source: 'mobile_app',
+          version: '2.1.0',
+        },
+      };
+
+      await client.events.track('order_placed', 'user_123', complexProperties);
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          properties: complexProperties,
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should throw error when API returns 400', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(400, 'Validation failed', mockErrors.validationError.details)
+      );
+
+      await expect(
+        client.events.track('', 'user_123')
+      ).rejects.toThrow('Validation failed');
+    });
+
+    it('should throw error when API returns 500', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(500, 'Internal server error')
+      );
+
+      await expect(
+        client.events.track('user-login', 'user_123')
+      ).rejects.toThrow('Internal server error');
+    });
+
+    it('should throw error when API returns 503 (queue full)', async () => {
+      mockAxiosInstance.post.mockRejectedValue(
+        mockErrorResponse(503, mockErrors.queueFullError.message)
+      );
+
+      await expect(
+        client.events.track('user-login', 'user_123')
+      ).rejects.toThrow('Event queue is full');
+    });
+
+    it('should handle network timeout', async () => {
+      const timeoutError = new Error('timeout of 10000ms exceeded');
+      (timeoutError as any).code = 'ECONNABORTED';
+      mockAxiosInstance.post.mockRejectedValue(timeoutError);
+
+      await expect(
+        client.events.track('user-login', 'user_123')
+      ).rejects.toThrow('timeout');
+    });
+
+    it('should handle properties with null values', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('user_updated', 'user_123', {
+        email: 'user@example.com',
+        phone: null,
+        address: null,
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          properties: {
+            email: 'user@example.com',
+            phone: null,
+            address: null,
+          },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle properties with boolean values', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('feature-toggled', 'user_123', {
+        feature_name: 'dark_mode',
+        enabled: true,
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          properties: {
+            feature_name: 'dark_mode',
+            enabled: true,
+          },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle properties with numeric values', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('score-updated', 'user_123', {
+        score: 1500,
+        multiplier: 1.5,
+        rank: 42,
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          properties: {
+            score: 1500,
+            multiplier: 1.5,
+            rank: 42,
+          },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle empty string properties', async () => {
+      mockAxiosInstance.post.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('form-submitted', 'user_123', {
+        name: 'John Doe',
+        comment: '',
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        expect.objectContaining({
+          properties: {
+            name: 'John Doe',
+            comment: '',
+          },
+        }),
+        expect.any(Object)
+      );
+    });
+  });
+});

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

@@ -0,0 +1,124 @@
+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('Leaderboards 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('getGlobal', () => {
+    it('should get global leaderboard with default parameters', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.leaderboardResponse)
+      );
+
+      const result = await client.leaderboards.getGlobal();
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/leaderboard', {
+        params: { timeframe: 'all-time', page: 1, limit: 50 },
+      });
+      expect(result).toEqual(mockResponses.leaderboardResponse);
+      expect(result.rankings).toHaveLength(2);
+    });
+
+    it('should get global leaderboard with weekly timeframe', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.leaderboardResponse)
+      );
+
+      await client.leaderboards.getGlobal('weekly');
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/leaderboard', {
+        params: { timeframe: 'weekly', page: 1, limit: 50 },
+      });
+    });
+
+    it('should get global leaderboard with monthly timeframe', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.leaderboardResponse)
+      );
+
+      await client.leaderboards.getGlobal('monthly');
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/leaderboard', {
+        params: { timeframe: 'monthly', page: 1, limit: 50 },
+      });
+    });
+
+    it('should get global leaderboard with custom pagination', async () => {
+      mockAxiosInstance.get.mockResolvedValue(
+        mockSuccessResponse(mockResponses.leaderboardResponse)
+      );
+
+      await client.leaderboards.getGlobal('all-time', 2, 25);
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/leaderboard', {
+        params: { timeframe: 'all-time', page: 2, limit: 25 },
+      });
+    });
+
+    it('should handle empty leaderboard', async () => {
+      const emptyLeaderboard = {
+        ...mockResponses.leaderboardResponse,
+        rankings: [],
+        total: 0,
+      };
+      mockAxiosInstance.get.mockResolvedValue(mockSuccessResponse(emptyLeaderboard));
+
+      const result = await client.leaderboards.getGlobal();
+
+      expect(result.rankings).toEqual([]);
+      expect(result.total).toBe(0);
+    });
+
+    it('should throw error for invalid timeframe', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(400, mockErrors.invalidTimeframeError.message)
+      );
+
+      await expect(
+        client.leaderboards.getGlobal('invalid' as any)
+      ).rejects.toThrow('Timeframe must be one of');
+    });
+
+    it('should throw error for invalid pagination', async () => {
+      mockAxiosInstance.get.mockRejectedValue(
+        mockErrorResponse(400, mockErrors.invalidPaginationError.message)
+      );
+
+      await expect(
+        client.leaderboards.getGlobal('all-time', 1, 150)
+      ).rejects.toThrow('Limit must be between 1 and 100');
+    });
+
+    it('should handle leaderboard with users at same rank', async () => {
+      const leaderboardWithTies = {
+        ...mockResponses.leaderboardResponse,
+        rankings: [
+          { rank: 1, user_id: 'user1', points: 1000, level: null },
+          { rank: 1, user_id: 'user2', points: 1000, level: null },
+          { rank: 3, user_id: 'user3', points: 900, level: null },
+        ],
+      };
+      mockAxiosInstance.get.mockResolvedValue(mockSuccessResponse(leaderboardWithTies));
+
+      const result = await client.leaderboards.getGlobal();
+
+      expect(result.rankings[0].rank).toBe(1);
+      expect(result.rankings[1].rank).toBe(1);
+      expect(result.rankings[2].rank).toBe(3);
+    });
+  });
+});