@rooguys/sdk 0.1.0 → 1.0.0

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

@@ -1,32 +1,32 @@
-import axios from 'axios';
 import { Rooguys } from '../../index';
-import { createMockAxiosInstance, mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import {
+  createMockRooguysClient,
+  setupMockRequest,
+  setupMockRequestError,
+  expectRequestWith,
+  MockAxiosInstance,
+} 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';
+  let mockAxios: MockAxiosInstance;
 
   beforeEach(() => {
-    mockAxiosInstance = createMockAxiosInstance();
-    mockedAxios.create.mockReturnValue(mockAxiosInstance as any);
-    client = new Rooguys(apiKey);
-    jest.clearAllMocks();
+    const mock = createMockRooguysClient();
+    client = mock.client;
+    mockAxios = mock.mockAxios;
   });
 
   describe('list', () => {
     it('should list badges with default parameters', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.badgesListResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.badgesListResponse);
 
       const result = await client.badges.list();
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/badges', {
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/badges',
         params: { page: 1, limit: 50, active_only: false },
       });
       expect(result).toEqual(mockResponses.badgesListResponse);
@@ -34,25 +34,25 @@ describe('Badges Resource', () => {
     });
 
     it('should list badges with custom pagination', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.badgesListResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.badgesListResponse);
 
       await client.badges.list(2, 25);
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/badges', {
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/badges',
         params: { page: 2, limit: 25, active_only: false },
       });
     });
 
     it('should list only active badges', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.badgesListResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.badgesListResponse);
 
       await client.badges.list(1, 50, true);
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/badges', {
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/badges',
         params: { page: 1, limit: 50, active_only: true },
       });
     });
@@ -67,7 +67,7 @@ describe('Badges Resource', () => {
           totalPages: 0,
         },
       };
-      mockAxiosInstance.get.mockResolvedValue(mockSuccessResponse(emptyResponse));
+      setupMockRequest(mockAxios, emptyResponse);
 
       const result = await client.badges.list();
 
@@ -76,9 +76,7 @@ describe('Badges Resource', () => {
     });
 
     it('should throw error for invalid pagination', async () => {
-      mockAxiosInstance.get.mockRejectedValue(
-        mockErrorResponse(400, mockErrors.invalidPaginationError.message)
-      );
+      setupMockRequestError(mockAxios, 400, 'Limit must be between 1 and 100');
 
       await expect(client.badges.list(1, 150)).rejects.toThrow(
         'Limit must be between 1 and 100'
@@ -86,9 +84,7 @@ describe('Badges Resource', () => {
     });
 
     it('should handle badges with all fields', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.badgesListResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.badgesListResponse);
 
       const result = await client.badges.list();
 
@@ -102,9 +98,7 @@ describe('Badges Resource', () => {
     });
 
     it('should handle server error', async () => {
-      mockAxiosInstance.get.mockRejectedValue(
-        mockErrorResponse(500, 'Internal server error')
-      );
+      setupMockRequestError(mockAxios, 500, 'Internal server error');
 
       await expect(client.badges.list()).rejects.toThrow('Internal server error');
     });

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

@@ -1,187 +1,155 @@
-import axios from 'axios';
-import { Rooguys } from '../../index';
-import { createMockAxiosInstance } from '../utils/mockClient';
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
+import { Rooguys, ValidationError } from '../../index';
 
 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',
-          }),
-        })
-      );
+      expect(client.apiKey).toBe('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',
-        })
-      );
+      const client = new Rooguys('test-api-key');
+      expect(client.baseUrl).toBe('https://api.rooguys.com/v1');
     });
 
     it('should use custom base URL when provided', () => {
-      new Rooguys('test-api-key', {
+      const client = new Rooguys('test-api-key', {
         baseUrl: 'https://custom.api.com/v1',
       });
-
-      expect(mockedAxios.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          baseURL: 'https://custom.api.com/v1',
-        })
-      );
+      expect(client.baseUrl).toBe('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,
-        })
-      );
+      const client = new Rooguys('test-api-key');
+      expect(client.timeout).toBe(10000);
     });
 
     it('should use custom timeout when provided', () => {
-      new Rooguys('test-api-key', {
+      const client = 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',
-          }),
-        })
-      );
+      expect(client.timeout).toBe(30000);
     });
 
     it('should accept both baseUrl and timeout options', () => {
-      new Rooguys('test-api-key', {
+      const client = 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,
-        })
-      );
+      expect(client.baseUrl).toBe('https://staging.api.com/v1');
+      expect(client.timeout).toBe(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,
-        })
-      );
+      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', () => {
-      new Rooguys('test-api-key', {
+      const client = new Rooguys('test-api-key', {
         baseUrl: 'http://localhost:3001/v1',
       });
-
-      expect(mockedAxios.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          baseURL: 'http://localhost:3001/v1',
-        })
-      );
+      expect(client.baseUrl).toBe('http://localhost:3001/v1');
     });
 
     it('should handle very short timeout', () => {
-      new Rooguys('test-api-key', {
+      const client = new Rooguys('test-api-key', {
         timeout: 1000,
       });
-
-      expect(mockedAxios.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          timeout: 1000,
-        })
-      );
+      expect(client.timeout).toBe(1000);
     });
 
     it('should handle very long timeout', () => {
-      new Rooguys('test-api-key', {
+      const client = new Rooguys('test-api-key', {
         timeout: 60000,
       });
+      expect(client.timeout).toBe(60000);
+    });
 
-      expect(mockedAxios.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          timeout: 60000,
-        })
-      );
+    it('should throw error when API key is missing', () => {
+      expect(() => new Rooguys('')).toThrow(ValidationError);
+      expect(() => new Rooguys('')).toThrow('API key is required');
     });
   });
 
   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 store API key', () => {
+      const client = new Rooguys('my-secret-key');
+      expect(client.apiKey).toBe('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,
-          }),
-        })
-      );
+      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';
-      new Rooguys(keyWithSpecialChars);
-
-      expect(mockedAxios.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            'x-api-key': keyWithSpecialChars,
-          }),
-        })
-      );
+      const client = new Rooguys(keyWithSpecialChars);
+      expect(client.apiKey).toBe(keyWithSpecialChars);
+    });
+  });
+
+  describe('module availability', () => {
+    it('should have events module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.events).toBeDefined();
+      expect(client.events.track).toBeDefined();
+      expect(client.events.trackBatch).toBeDefined();
+    });
+
+    it('should have users module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.users).toBeDefined();
+      expect(client.users.get).toBeDefined();
+      expect(client.users.create).toBeDefined();
+      expect(client.users.update).toBeDefined();
+      expect(client.users.getBulk).toBeDefined();
+      expect(client.users.getBadges).toBeDefined();
+      expect(client.users.getRank).toBeDefined();
+    });
+
+    it('should have leaderboards module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.leaderboards).toBeDefined();
+      expect(client.leaderboards.getGlobal).toBeDefined();
+      expect(client.leaderboards.list).toBeDefined();
+      expect(client.leaderboards.getCustom).toBeDefined();
+    });
+
+    it('should have badges module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.badges).toBeDefined();
+      expect(client.badges.list).toBeDefined();
+    });
+
+    it('should have levels module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.levels).toBeDefined();
+      expect(client.levels.list).toBeDefined();
+    });
+
+    it('should have questionnaires module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.questionnaires).toBeDefined();
+      expect(client.questionnaires.get).toBeDefined();
+      expect(client.questionnaires.getActive).toBeDefined();
+    });
+
+    it('should have aha module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.aha).toBeDefined();
+      expect(client.aha.declare).toBeDefined();
+      expect(client.aha.getUserScore).toBeDefined();
+    });
+
+    it('should have health module', () => {
+      const client = new Rooguys('test-api-key');
+      expect(client.health).toBeDefined();
+      expect(client.health.check).toBeDefined();
+      expect(client.health.isReady).toBeDefined();
     });
   });
 });