@rooguys/js 0.1.0

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

@@ -0,0 +1,68 @@
+import Rooguys from '../../index';
+import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+describe('Badges Resource', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('list', () => {
+    it('should list badges with default parameters', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.badgesListResponse));
+
+      const result = await client.badges.list();
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=1');
+      expect(callUrl).toContain('limit=50');
+      expect(callUrl).toContain('active_only=false');
+      expect(result.badges).toHaveLength(1);
+    });
+
+    it('should list badges with custom pagination', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.badgesListResponse));
+
+      await client.badges.list(2, 25);
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=25');
+    });
+
+    it('should list only active badges', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.badgesListResponse));
+
+      await client.badges.list(1, 50, true);
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('active_only=true');
+    });
+
+    it('should handle empty badge list', async () => {
+      const emptyResponse = {
+        badges: [],
+        pagination: { page: 1, limit: 50, total: 0, totalPages: 0 },
+      };
+      global.fetch.mockResolvedValue(mockSuccessResponse(emptyResponse));
+
+      const result = await client.badges.list();
+
+      expect(result.badges).toEqual([]);
+    });
+
+    it('should throw error for invalid pagination', async () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(400, mockErrors.invalidPaginationError.message)
+      );
+
+      await expect(client.badges.list(1, 150)).rejects.toThrow(
+        'Limit must be between 1 and 100'
+      );
+    });
+  });
+});

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

@@ -0,0 +1,97 @@
+import Rooguys from '../../index';
+
+describe('SDK Configuration', () => {
+  beforeEach(() => {
+    global.fetch.mockClear();
+  });
+
+  describe('initialization', () => {
+    it('should initialize with API key', () => {
+      const client = new Rooguys('test-api-key');
+
+      expect(client.apiKey).toBe('test-api-key');
+    });
+
+    it('should use default base URL when not provided', () => {
+      const client = new Rooguys('test-api-key');
+
+      expect(client.baseUrl).toBe('https://api.rooguys.com/v1');
+    });
+
+    it('should use custom base URL when provided', () => {
+      const client = new Rooguys('test-api-key', {
+        baseUrl: 'https://custom.api.com/v1',
+      });
+
+      expect(client.baseUrl).toBe('https://custom.api.com/v1');
+    });
+
+    it('should use default timeout when not provided', () => {
+      const client = new Rooguys('test-api-key');
+
+      expect(client.timeout).toBe(10000);
+    });
+
+    it('should use custom timeout when provided', () => {
+      const client = new Rooguys('test-api-key', {
+        timeout: 30000,
+      });
+
+      expect(client.timeout).toBe(30000);
+    });
+
+    it('should accept both baseUrl and timeout options', () => {
+      const client = new Rooguys('test-api-key', {
+        baseUrl: 'https://staging.api.com/v1',
+        timeout: 20000,
+      });
+
+      expect(client.baseUrl).toBe('https://staging.api.com/v1');
+      expect(client.timeout).toBe(20000);
+    });
+
+    it('should handle empty options object', () => {
+      const client = new Rooguys('test-api-key', {});
+
+      expect(client.baseUrl).toBe('https://api.rooguys.com/v1');
+      expect(client.timeout).toBe(10000);
+    });
+
+    it('should handle localhost base URL', () => {
+      const client = new Rooguys('test-api-key', {
+        baseUrl: 'http://localhost:3001/v1',
+      });
+
+      expect(client.baseUrl).toBe('http://localhost:3001/v1');
+    });
+  });
+
+  describe('API key handling', () => {
+    it('should include API key in all requests', async () => {
+      const client = new Rooguys('my-secret-key');
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await client.events.track('test', 'user1');
+
+      const callHeaders = global.fetch.mock.calls[0][1].headers;
+      expect(callHeaders['x-api-key']).toBe('my-secret-key');
+    });
+
+    it('should handle long API keys', () => {
+      const longKey = 'sk_live_' + 'a'.repeat(100);
+      const client = new Rooguys(longKey);
+
+      expect(client.apiKey).toBe(longKey);
+    });
+
+    it('should handle API keys with special characters', () => {
+      const keyWithSpecialChars = 'sk_test_abc-123_XYZ.456';
+      const client = new Rooguys(keyWithSpecialChars);
+
+      expect(client.apiKey).toBe(keyWithSpecialChars);
+    });
+  });
+});

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

@@ -0,0 +1,141 @@
+import Rooguys from '../../index';
+import { mockErrorResponse, mockTimeoutError, mockNetworkError } from '../utils/mockClient';
+import { mockErrors } from '../fixtures/responses';
+
+describe('Error Handling', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('4xx client errors', () => {
+    it('should throw error with message for 400 Bad Request', async () => {
+      global.fetch.mockResolvedValue(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 () => {
+      global.fetch.mockResolvedValue(
+        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 () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(404, mockErrors.notFoundError.message)
+      );
+
+      await expect(client.users.get('nonexistent')).rejects.toThrow("User 'user123' does not exist in this project");
+    });
+
+    it('should throw error for 429 Too Many Requests', async () => {
+      global.fetch.mockResolvedValue(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 () => {
+      global.fetch.mockResolvedValue(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 () => {
+      global.fetch.mockResolvedValue(
+        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 () => {
+      global.fetch.mockResolvedValue(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 () => {
+      global.fetch.mockRejectedValue(mockTimeoutError());
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow('aborted');
+    });
+
+    it('should throw error for network failure', async () => {
+      global.fetch.mockRejectedValue(mockNetworkError('Network request failed'));
+
+      await expect(client.users.get('user1')).rejects.toThrow('Network');
+    });
+
+    it('should throw error for connection refused', async () => {
+      global.fetch.mockRejectedValue(mockNetworkError('Failed to fetch'));
+
+      await expect(client.users.get('user1')).rejects.toThrow('Failed to fetch');
+    });
+  });
+
+  describe('malformed responses', () => {
+    it('should handle response without error message', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: () => Promise.resolve({}),
+      });
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Internal Server Error'
+      );
+    });
+
+    it('should handle response with invalid JSON', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: () => Promise.reject(new Error('Invalid JSON')),
+      });
+
+      await expect(client.events.track('test', 'user1')).rejects.toThrow(
+        'Internal Server Error'
+      );
+    });
+  });
+
+  describe('error detail preservation', () => {
+    it('should preserve error details from API response', async () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(400, 'Validation failed', [
+          { field: 'user_id', message: 'User ID is required' },
+        ])
+      );
+
+      await expect(client.events.track('', '')).rejects.toThrow('Validation failed');
+    });
+
+    it('should handle errors with nested details', async () => {
+      global.fetch.mockResolvedValue(
+        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'
+      );
+    });
+  });
+});

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

@@ -0,0 +1,223 @@
+import Rooguys from '../../index';
+import { mockSuccessResponse, mockErrorResponse, mockTimeoutError } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+describe('Events Resource', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('track', () => {
+    it('should track an event with valid inputs', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      const result = await client.events.track('purchase_completed', 'user_123', {
+        amount: 50.0,
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/event'),
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'x-api-key': apiKey,
+            'Content-Type': 'application/json',
+          }),
+          body: JSON.stringify({
+            event_name: 'purchase_completed',
+            user_id: 'user_123',
+            properties: { amount: 50.0 },
+          }),
+        })
+      );
+      expect(result).toEqual(mockResponses.trackEventResponse);
+    });
+
+    it('should track an event with empty properties', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      const result = await client.events.track('user_login', 'user_456');
+
+      expect(global.fetch).toHaveBeenCalled();
+      expect(result).toEqual(mockResponses.trackEventResponse);
+    });
+
+    it('should include profile when includeProfile is true', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventWithProfileResponse)
+      );
+
+      const result = await client.events.track(
+        'purchase_completed',
+        'user_123',
+        { amount: 50.0 },
+        { includeProfile: true }
+      );
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('include_profile=true');
+      expect(result).toEqual(mockResponses.trackEventWithProfileResponse);
+      expect(result.profile).toBeDefined();
+    });
+
+    it('should handle special characters in event name', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('user-signup_v2', 'user_123');
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.event_name).toBe('user-signup_v2');
+    });
+
+    it('should handle special characters in user ID', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('user_login', 'user@example.com');
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.user_id).toBe('user@example.com');
+    });
+
+    it('should handle complex nested properties', async () => {
+      global.fetch.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);
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.properties).toEqual(complexProperties);
+    });
+
+    it('should throw error when API returns 400', async () => {
+      global.fetch.mockResolvedValue(
+        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 () => {
+      global.fetch.mockResolvedValue(
+        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 () => {
+      global.fetch.mockResolvedValue(
+        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 () => {
+      global.fetch.mockRejectedValue(mockTimeoutError());
+
+      await expect(
+        client.events.track('user_login', 'user_123')
+      ).rejects.toThrow('aborted');
+    });
+
+    it('should handle properties with null values', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('user_updated', 'user_123', {
+        email: 'user@example.com',
+        phone: null,
+        address: null,
+      });
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.properties).toEqual({
+        email: 'user@example.com',
+        phone: null,
+        address: null,
+      });
+    });
+
+    it('should handle properties with boolean values', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('feature_toggled', 'user_123', {
+        feature_name: 'dark_mode',
+        enabled: true,
+      });
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.properties.enabled).toBe(true);
+    });
+
+    it('should handle properties with numeric values', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('score_updated', 'user_123', {
+        score: 1500,
+        multiplier: 1.5,
+        rank: 42,
+      });
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.properties).toEqual({
+        score: 1500,
+        multiplier: 1.5,
+        rank: 42,
+      });
+    });
+
+    it('should handle empty string properties', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse(mockResponses.trackEventResponse)
+      );
+
+      await client.events.track('form_submitted', 'user_123', {
+        name: 'John Doe',
+        comment: '',
+      });
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody.properties.comment).toBe('');
+    });
+  });
+});

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

@@ -0,0 +1,113 @@
+import Rooguys from '../../index';
+import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+describe('Leaderboards Resource', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('getGlobal', () => {
+    it('should get global leaderboard with default parameters', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardResponse));
+
+      const result = await client.leaderboards.getGlobal();
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('timeframe=all-time');
+      expect(callUrl).toContain('page=1');
+      expect(callUrl).toContain('limit=50');
+      expect(result.rankings).toHaveLength(2);
+    });
+
+    it('should get global leaderboard with weekly timeframe', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardResponse));
+
+      await client.leaderboards.getGlobal('weekly');
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('timeframe=weekly');
+    });
+
+    it('should get global leaderboard with custom pagination', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardResponse));
+
+      await client.leaderboards.getGlobal('all-time', 2, 25);
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=25');
+    });
+
+    it('should throw error for invalid timeframe', async () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(400, mockErrors.invalidTimeframeError.message)
+      );
+
+      await expect(client.leaderboards.getGlobal('invalid')).rejects.toThrow(
+        'Timeframe must be one of'
+      );
+    });
+  });
+
+  describe('list', () => {
+    it('should list all leaderboards', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardsListResponse));
+
+      const result = await client.leaderboards.list();
+
+      expect(result.leaderboards).toHaveLength(1);
+      expect(result.pagination).toBeDefined();
+    });
+
+    it('should list leaderboards with search', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.leaderboardsListResponse));
+
+      await client.leaderboards.list(1, 50, 'top');
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('search=top');
+    });
+  });
+
+  describe('getCustom', () => {
+    it('should get custom leaderboard by ID', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.customLeaderboardResponse));
+
+      const result = await client.leaderboards.getCustom('lb1');
+
+      expect(result.leaderboard).toBeDefined();
+      expect(result.rankings).toBeDefined();
+    });
+
+    it('should throw 404 for non-existent leaderboard', async () => {
+      global.fetch.mockResolvedValue(mockErrorResponse(404, 'Leaderboard not found'));
+
+      await expect(client.leaderboards.getCustom('invalid_id')).rejects.toThrow(
+        'Leaderboard not found'
+      );
+    });
+  });
+
+  describe('getUserRank', () => {
+    it('should get user rank in custom leaderboard', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankResponse));
+
+      const result = await client.leaderboards.getUserRank('lb1', 'user_123');
+
+      expect(result.rank).toBe(42);
+    });
+
+    it('should throw 404 for non-existent user or leaderboard', async () => {
+      global.fetch.mockResolvedValue(mockErrorResponse(404, 'Not found'));
+
+      await expect(
+        client.leaderboards.getUserRank('lb1', 'invalid_user')
+      ).rejects.toThrow('Not found');
+    });
+  });
+});