@rooguys/sdk 0.1.0 → 1.0.0

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

@@ -1,33 +1,33 @@
-import axios from 'axios';
-import { Rooguys } from '../../index';
-import { createMockAxiosInstance, mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { Rooguys, ValidationError } from '../../index';
+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('Users 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('get', () => {
     it('should get a user profile', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.userProfile)
-      );
+      setupMockRequest(mockAxios, mockResponses.userProfile);
 
-      const result = await client.users.get('user_123');
+      const result = await client.users.get('user123');
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user_123');
-      expect(result).toEqual(mockResponses.userProfile);
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user123',
+      });
       expect(result.user_id).toBe('user123');
       expect(result.points).toBe(100);
     });
@@ -38,7 +38,7 @@ describe('Users Resource', () => {
         level: null,
         next_level: null,
       };
-      mockAxiosInstance.get.mockResolvedValue(mockSuccessResponse(userWithoutLevel));
+      setupMockRequest(mockAxios, userWithoutLevel);
 
       const result = await client.users.get('user_new');
 
@@ -51,7 +51,7 @@ describe('Users Resource', () => {
         ...mockResponses.userProfile,
         badges: [],
       };
-      mockAxiosInstance.get.mockResolvedValue(mockSuccessResponse(userWithoutBadges));
+      setupMockRequest(mockAxios, userWithoutBadges);
 
       const result = await client.users.get('user_123');
 
@@ -59,9 +59,7 @@ describe('Users Resource', () => {
     });
 
     it('should throw 404 error when user not found', async () => {
-      mockAxiosInstance.get.mockRejectedValue(
-        mockErrorResponse(404, mockErrors.notFoundError.message)
-      );
+      setupMockRequestError(mockAxios, 404, "User 'user123' does not exist in this project");
 
       await expect(client.users.get('nonexistent_user')).rejects.toThrow(
         "User 'user123' does not exist in this project"
@@ -69,35 +67,154 @@ describe('Users Resource', () => {
     });
 
     it('should handle special characters in user ID', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.userProfile)
-      );
+      setupMockRequest(mockAxios, mockResponses.userProfile);
 
       await client.users.get('user@example.com');
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user%40example.com');
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user%40example.com',
+      });
+    });
+
+    it('should support field selection', async () => {
+      setupMockRequest(mockAxios, mockResponses.userProfile);
+
+      await client.users.get('user123', { fields: ['points', 'level'] });
+
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user123',
+      });
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new user', async () => {
+      setupMockRequest(mockAxios, mockResponses.userProfile);
+
+      const result = await client.users.create({
+        userId: 'new_user',
+        displayName: 'New User',
+        email: 'new@example.com',
+      });
+
+      expectRequestWith(mockAxios, {
+        method: 'POST',
+        url: '/users',
+        data: {
+          user_id: 'new_user',
+          display_name: 'New User',
+          email: 'new@example.com',
+        },
+      });
+      expect(result).toBeDefined();
+    });
+
+    it('should throw error for missing user ID', async () => {
+      await expect(client.users.create({} as any)).rejects.toThrow(ValidationError);
+      await expect(client.users.create({} as any)).rejects.toThrow('User ID is required');
+    });
+
+    it('should throw error for invalid email format', async () => {
+      await expect(
+        client.users.create({ userId: 'user1', email: 'invalid-email' })
+      ).rejects.toThrow(ValidationError);
+      await expect(
+        client.users.create({ userId: 'user1', email: 'invalid-email' })
+      ).rejects.toThrow('Invalid email format');
+    });
+  });
+
+  describe('update', () => {
+    it('should update an existing user', async () => {
+      setupMockRequest(mockAxios, mockResponses.userProfile);
+
+      const result = await client.users.update('user123', {
+        displayName: 'Updated Name',
+      });
+
+      expectRequestWith(mockAxios, {
+        method: 'PATCH',
+        url: '/users/user123',
+        data: {
+          display_name: 'Updated Name',
+        },
+      });
+      expect(result).toBeDefined();
+    });
+
+    it('should throw error for missing user ID', async () => {
+      await expect(client.users.update('', { displayName: 'Test' })).rejects.toThrow(ValidationError);
+    });
+
+    it('should throw error for invalid email format', async () => {
+      await expect(
+        client.users.update('user123', { email: 'invalid-email' })
+      ).rejects.toThrow(ValidationError);
+    });
+  });
+
+  describe('createBatch', () => {
+    it('should create multiple users', async () => {
+      const batchResponse = { created: 2, failed: 0 };
+      setupMockRequest(mockAxios, batchResponse);
+
+      const users = [
+        { userId: 'user1', displayName: 'User 1' },
+        { userId: 'user2', displayName: 'User 2' },
+      ];
+
+      const result = await client.users.createBatch(users);
+
+      expectRequestWith(mockAxios, {
+        method: 'POST',
+        url: '/users/batch',
+      });
+      expect(result).toEqual(batchResponse);
+    });
+
+    it('should throw error for empty users array', async () => {
+      await expect(client.users.createBatch([])).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch([])).rejects.toThrow('cannot be empty');
+    });
+
+    it('should throw error for more than 100 users', async () => {
+      const manyUsers = Array.from({ length: 101 }, (_, i) => ({
+        userId: `user_${i}`,
+      }));
+
+      await expect(client.users.createBatch(manyUsers)).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch(manyUsers)).rejects.toThrow('maximum of 100');
+    });
+
+    it('should throw error for user without userId', async () => {
+      const users = [{ displayName: 'User 1' }] as any;
+
+      await expect(client.users.createBatch(users)).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch(users)).rejects.toThrow('User ID is required');
     });
   });
 
   describe('getBulk', () => {
     it('should get multiple user profiles', async () => {
-      mockAxiosInstance.post.mockResolvedValue(
-        mockSuccessResponse(mockResponses.bulkUsersResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.bulkUsersResponse);
 
       const result = await client.users.getBulk(['user1', 'user2']);
 
-      expect(mockAxiosInstance.post).toHaveBeenCalledWith('/users/bulk', {
-        user_ids: ['user1', 'user2'],
+      expectRequestWith(mockAxios, {
+        method: 'POST',
+        url: '/users/bulk',
+        data: {
+          user_ids: ['user1', 'user2'],
+        },
       });
       expect(result).toEqual(mockResponses.bulkUsersResponse);
       expect(result.users).toHaveLength(2);
     });
 
     it('should handle single user in bulk request', async () => {
-      mockAxiosInstance.post.mockResolvedValue(
-        mockSuccessResponse({ users: [mockResponses.userProfile] })
-      );
+      setupMockRequest(mockAxios, { users: [mockResponses.userProfile] });
 
       const result = await client.users.getBulk(['user_123']);
 
@@ -105,45 +222,30 @@ describe('Users Resource', () => {
     });
 
     it('should handle empty results', async () => {
-      mockAxiosInstance.post.mockResolvedValue(
-        mockSuccessResponse({ users: [] })
-      );
+      setupMockRequest(mockAxios, { users: [] });
 
       const result = await client.users.getBulk(['nonexistent1', 'nonexistent2']);
 
       expect(result.users).toEqual([]);
     });
-
-    it('should throw error for more than 100 users', async () => {
-      mockAxiosInstance.post.mockRejectedValue(
-        mockErrorResponse(400, 'Maximum 100 user IDs allowed')
-      );
-
-      const manyUsers = Array.from({ length: 101 }, (_, i) => `user_${i}`);
-
-      await expect(client.users.getBulk(manyUsers)).rejects.toThrow(
-        'Maximum 100 user IDs allowed'
-      );
-    });
   });
 
   describe('getBadges', () => {
     it('should get user badges', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse({ badges: mockResponses.userProfile.badges })
-      );
+      setupMockRequest(mockAxios, { badges: mockResponses.userProfile.badges });
 
       const result = await client.users.getBadges('user_123');
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user_123/badges');
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user_123/badges',
+      });
       expect(result.badges).toHaveLength(1);
       expect(result.badges[0].name).toBe('First Steps');
     });
 
     it('should handle user with no badges', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse({ badges: [] })
-      );
+      setupMockRequest(mockAxios, { badges: [] });
 
       const result = await client.users.getBadges('user_new');
 
@@ -151,9 +253,7 @@ describe('Users Resource', () => {
     });
 
     it('should throw 404 error when user not found', async () => {
-      mockAxiosInstance.get.mockRejectedValue(
-        mockErrorResponse(404, mockErrors.notFoundError.message)
-      );
+      setupMockRequestError(mockAxios, 404, "User 'user123' does not exist in this project");
 
       await expect(client.users.getBadges('nonexistent_user')).rejects.toThrow(
         "User 'user123' does not exist in this project"
@@ -163,47 +263,41 @@ describe('Users Resource', () => {
 
   describe('getRank', () => {
     it('should get user rank with default timeframe', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.userRankResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.userRankResponse);
 
       const result = await client.users.getRank('user_123');
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user_123/rank', {
-        params: { timeframe: 'all-time' },
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user_123/rank',
       });
-      expect(result).toEqual(mockResponses.userRankResponse);
       expect(result.rank).toBe(42);
     });
 
     it('should get user rank with weekly timeframe', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.userRankResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.userRankResponse);
 
       await client.users.getRank('user_123', 'weekly');
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user_123/rank', {
-        params: { timeframe: 'weekly' },
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user_123/rank',
       });
     });
 
     it('should get user rank with monthly timeframe', async () => {
-      mockAxiosInstance.get.mockResolvedValue(
-        mockSuccessResponse(mockResponses.userRankResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.userRankResponse);
 
       await client.users.getRank('user_123', 'monthly');
 
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user_123/rank', {
-        params: { timeframe: 'monthly' },
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/user_123/rank',
       });
     });
 
     it('should throw 404 error when user not found', async () => {
-      mockAxiosInstance.get.mockRejectedValue(
-        mockErrorResponse(404, mockErrors.notFoundError.message)
-      );
+      setupMockRequestError(mockAxios, 404, "User 'user123' does not exist in this project");
 
       await expect(client.users.getRank('nonexistent_user')).rejects.toThrow(
         "User 'user123' does not exist in this project"
@@ -213,9 +307,7 @@ describe('Users Resource', () => {
 
   describe('submitAnswers', () => {
     it('should submit questionnaire answers', async () => {
-      mockAxiosInstance.post.mockResolvedValue(
-        mockSuccessResponse(mockResponses.answerSubmissionResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.answerSubmissionResponse);
 
       const answers = [
         { question_id: 'q1', answer_option_id: 'a1' },
@@ -228,30 +320,30 @@ describe('Users Resource', () => {
         answers
       );
 
-      expect(mockAxiosInstance.post).toHaveBeenCalledWith('/user/user_123/answers', {
-        questionnaire_id: 'questionnaire_id',
-        answers,
+      expectRequestWith(mockAxios, {
+        method: 'POST',
+        url: '/users/user_123/answers',
+        data: {
+          questionnaire_id: 'questionnaire_id',
+          answers,
+        },
       });
       expect(result).toEqual(mockResponses.answerSubmissionResponse);
       expect(result.status).toBe('accepted');
     });
 
     it('should handle single answer submission', async () => {
-      mockAxiosInstance.post.mockResolvedValue(
-        mockSuccessResponse(mockResponses.answerSubmissionResponse)
-      );
+      setupMockRequest(mockAxios, mockResponses.answerSubmissionResponse);
 
       const answers = [{ question_id: 'q1', answer_option_id: 'a1' }];
 
       await client.users.submitAnswers('user_123', 'questionnaire_id', answers);
 
-      expect(mockAxiosInstance.post).toHaveBeenCalled();
+      expect(mockAxios.request).toHaveBeenCalled();
     });
 
     it('should throw error for invalid questionnaire ID', async () => {
-      mockAxiosInstance.post.mockRejectedValue(
-        mockErrorResponse(400, 'Invalid questionnaire ID')
-      );
+      setupMockRequestError(mockAxios, 400, 'Invalid questionnaire ID');
 
       const answers = [{ question_id: 'q1', answer_option_id: 'a1' }];
 
@@ -259,15 +351,38 @@ describe('Users Resource', () => {
         client.users.submitAnswers('user_123', 'invalid_id', answers)
       ).rejects.toThrow('Invalid questionnaire ID');
     });
+  });
 
-    it('should throw error for empty answers array', async () => {
-      mockAxiosInstance.post.mockRejectedValue(
-        mockErrorResponse(400, 'Answers must be a non-empty array')
-      );
+  describe('search', () => {
+    it('should search users', async () => {
+      const searchResponse = {
+        users: [mockResponses.userProfile],
+        pagination: { page: 1, limit: 50, total: 1, totalPages: 1 },
+      };
+      setupMockRequest(mockAxios, searchResponse);
 
-      await expect(
-        client.users.submitAnswers('user_123', 'questionnaire_id', [])
-      ).rejects.toThrow('non-empty array');
+      const result = await client.users.search('john');
+
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/search',
+      });
+      expect(result.users).toHaveLength(1);
+    });
+
+    it('should search users with pagination', async () => {
+      const searchResponse = {
+        users: [],
+        pagination: { page: 2, limit: 25, total: 0, totalPages: 0 },
+      };
+      setupMockRequest(mockAxios, searchResponse);
+
+      await client.users.search('john', { page: 2, limit: 25 });
+
+      expectRequestWith(mockAxios, {
+        method: 'GET',
+        url: '/users/search',
+      });
     });
   });
 });

package/src/__tests__/utils/mockClient.ts

@@ -1,8 +1,14 @@
-import { AxiosInstance } from 'axios';
+import { AxiosResponse } from 'axios';
+import { Rooguys } from '../../index';
+import { HttpClient, ApiResponse, RateLimitInfo } from '../../http-client';
 
 export interface MockAxiosInstance {
   get: jest.Mock;
   post: jest.Mock;
+  put: jest.Mock;
+  patch: jest.Mock;
+  delete: jest.Mock;
+  request: jest.Mock;
   defaults: {
     headers: {
       common: Record<string, string>;
@@ -18,6 +24,10 @@ export function createMockAxiosInstance(): MockAxiosInstance {
   return {
     get: jest.fn(),
     post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn(),
+    request: jest.fn(),
     defaults: {
       headers: {
         common: {},
@@ -30,19 +40,196 @@ export function createMockAxiosInstance(): MockAxiosInstance {
   };
 }
 
-export function mockSuccessResponse<T>(data: T) {
-  return { data };
+/**
+ * Create a mock Rooguys client with mocked HTTP client
+ * Returns both the client and the mock axios instance for setting up expectations
+ */
+export function createMockRooguysClient(apiKey = 'test-api-key'): {
+  client: Rooguys;
+  mockAxios: MockAxiosInstance;
+} {
+  const client = new Rooguys(apiKey);
+  const mockAxios = createMockAxiosInstance();
+  
+  // Access the internal HttpClient and replace its axios instance
+  const httpClient = (client as any)._httpClient as HttpClient;
+  (httpClient as any).client = mockAxios;
+  
+  return { client, mockAxios };
 }
 
-export function mockErrorResponse(status: number, message: string, details?: any) {
+/**
+ * Create a mock AxiosResponse with rate limit headers
+ */
+export function mockAxiosResponse<T>(
+  data: T,
+  status = 200,
+  headers: Record<string, string> = {}
+): AxiosResponse<T> {
+  return {
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : 'Error',
+    headers: {
+      'x-ratelimit-limit': '1000',
+      'x-ratelimit-remaining': '999',
+      'x-ratelimit-reset': String(Math.floor(Date.now() / 1000) + 3600),
+      ...headers,
+    },
+    config: {} as any,
+  };
+}
+
+/**
+ * Create a mock AxiosResponse for standardized API format
+ */
+export function mockStandardizedResponse<T>(
+  data: T,
+  requestId = 'req-123',
+  headers: Record<string, string> = {}
+): AxiosResponse<{ success: true; data: T; request_id: string }> {
+  return mockAxiosResponse(
+    {
+      success: true as const,
+      data,
+      request_id: requestId,
+    },
+    200,
+    {
+      'x-request-id': requestId,
+      ...headers,
+    }
+  );
+}
+
+/**
+ * Create a mock success response (legacy format - data directly in response)
+ */
+export function mockSuccessResponse<T>(
+  data: T,
+  headers: Record<string, string> = {}
+): AxiosResponse<T> {
+  return mockAxiosResponse(data, 200, headers);
+}
+
+/**
+ * Create a mock error that mimics an Axios error
+ */
+export function mockErrorResponse(
+  status: number,
+  message: string,
+  code?: string,
+  details?: Array<{ field: string; message: string }>
+): any {
   const error: any = new Error(message);
   error.response = {
     status,
     data: {
-      error: message,
-      details,
+      success: false,
+      error: {
+        message,
+        code: code || 'ERROR',
+        details,
+      },
+      request_id: 'req-error-123',
+    },
+    headers: {
+      'x-ratelimit-limit': '1000',
+      'x-ratelimit-remaining': '999',
+      'x-ratelimit-reset': String(Math.floor(Date.now() / 1000) + 3600),
+      'x-request-id': 'req-error-123',
+    },
+  };
+  error.isAxiosError = true;
+  return error;
+}
+
+/**
+ * Create a mock rate limit error
+ */
+export function mockRateLimitError(retryAfter = 60): any {
+  const error: any = new Error('Rate limit exceeded');
+  error.response = {
+    status: 429,
+    data: {
+      success: false,
+      error: {
+        message: 'Rate limit exceeded',
+        code: 'RATE_LIMIT_EXCEEDED',
+      },
+      request_id: 'req-ratelimit-123',
+    },
+    headers: {
+      'x-ratelimit-limit': '1000',
+      'x-ratelimit-remaining': '0',
+      'x-ratelimit-reset': String(Math.floor(Date.now() / 1000) + retryAfter),
+      'retry-after': String(retryAfter),
+      'x-request-id': 'req-ratelimit-123',
     },
   };
   error.isAxiosError = true;
   return error;
 }
+
+/**
+ * Helper to set up mock for a successful request
+ * The mock axios instance uses request() method internally
+ */
+export function setupMockRequest<T>(
+  mockAxios: MockAxiosInstance,
+  responseData: T,
+  headers: Record<string, string> = {}
+): void {
+  mockAxios.request.mockResolvedValue(mockAxiosResponse(responseData, 200, headers));
+}
+
+/**
+ * Helper to set up mock for a failed request
+ */
+export function setupMockRequestError(
+  mockAxios: MockAxiosInstance,
+  status: number,
+  message: string,
+  code?: string,
+  details?: Array<{ field: string; message: string }>
+): void {
+  mockAxios.request.mockRejectedValue(mockErrorResponse(status, message, code, details));
+}
+
+/**
+ * Get the last request config from mock axios
+ */
+export function getLastRequestConfig(mockAxios: MockAxiosInstance): any {
+  const calls = mockAxios.request.mock.calls;
+  if (calls.length === 0) return null;
+  return calls[calls.length - 1][0];
+}
+
+/**
+ * Assert that a request was made with specific config
+ */
+export function expectRequestWith(
+  mockAxios: MockAxiosInstance,
+  expected: {
+    method?: string;
+    url?: string;
+    data?: any;
+    params?: any;
+  }
+): void {
+  const lastConfig = getLastRequestConfig(mockAxios);
+  expect(lastConfig).toBeTruthy();
+  
+  if (expected.method) {
+    expect(lastConfig.method).toBe(expected.method);
+  }
+  if (expected.url) {
+    expect(lastConfig.url).toBe(expected.url);
+  }
+  if (expected.data) {
+    expect(lastConfig.data).toEqual(expected.data);
+  }
+  if (expected.params) {
+    expect(lastConfig.params).toEqual(expected.params);
+  }
+}