@scalekit-sdk/node 2.0.1 → 2.1.0

package/tests/users.test.ts

@@ -0,0 +1,168 @@
+import ScalekitClient from '../src/scalekit';
+import { CreateUserRequest, UpdateUserRequest } from '../src/types/user';
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { TestDataGenerator, TestOrganizationManager, TestUserManager } from './utils/test-data';
+
+describe('Users', () => {
+  let client: ScalekitClient;
+  let testOrg: string;
+  let userId: string | null = null;
+  let sharedUserData: CreateUserRequest;
+
+  beforeEach(async () => {
+    // Use global client
+    client = global.client;
+    
+    // Create test organization for each test
+    testOrg = await TestOrganizationManager.createTestOrganization(client);
+    
+    // Create a shared user for testing
+    sharedUserData = TestDataGenerator.generateUserData();
+    const createResponse = await client.user.createUserAndMembership(testOrg, sharedUserData);
+    userId = createResponse.user?.id || null;
+    expect(userId).toBeDefined();
+  });
+
+  afterEach(async () => {
+    // Clean up test resources
+    if (userId) {
+      await TestUserManager.cleanupTestUser(client, testOrg, userId);
+      userId = null;
+    }
+    
+    // Clean up test organization
+    await TestOrganizationManager.cleanupTestOrganization(client, testOrg);
+  });
+
+  describe('listOrganizationUsers', () => {
+    it('should list users by organization', async () => {
+      // List users in the organization
+      const usersList = await client.user.listOrganizationUsers(testOrg, TestDataGenerator.generatePaginationParams());
+
+      expect(usersList).toBeDefined();
+      expect(usersList.users).toBeDefined();
+      expect(Array.isArray(usersList.users)).toBe(true);
+      expect(usersList.users.length).toBeGreaterThan(0);
+
+      // Verify basic user attributes
+      const firstUser = usersList.users[0];
+      expect(firstUser.id).toBeDefined();
+      expect(firstUser.email).toBeDefined();
+      expect(firstUser.environmentId).toBeDefined();
+    });
+
+    it('should handle pagination', async () => {
+      const firstPage = await client.user.listOrganizationUsers(testOrg, TestDataGenerator.generatePaginationParams(5));
+
+      expect(firstPage).toBeDefined();
+      expect(firstPage.users.length).toBeLessThanOrEqual(5);
+
+      if (firstPage.nextPageToken) {
+        const secondPage = await client.user.listOrganizationUsers(testOrg, {
+          pageSize: 5,
+          pageToken: firstPage.nextPageToken
+        });
+
+        expect(secondPage).toBeDefined();
+        expect(secondPage.users).toBeDefined();
+      }
+    });
+  });
+
+  describe('getUser', () => {
+    it('should get user by ID', async () => {
+      // Retrieve the user by ID
+      const user = await client.user.getUser(userId!);
+      
+      expect(user).toBeDefined();
+      expect(user.user).toBeDefined();
+      expect(user.user?.id).toBe(userId);
+      expect(user.user?.email).toBe(sharedUserData.email);
+    });
+  });
+
+  describe('createUserAndMembership', () => {
+    it('should create user and membership', async () => {
+      // Create a new user for this specific test
+      const userData = TestDataGenerator.generateUserData();
+      let newUserId: string | null = null;
+
+      try {
+        const response = await client.user.createUserAndMembership(testOrg, userData);
+        
+        expect(response).toBeDefined();
+        expect(response.user).toBeDefined();
+        expect(response.user?.id).toBeDefined();
+        expect(response.user?.email).toBe(userData.email);
+        expect(response.user?.metadata?.source).toBe('test');
+        
+        newUserId = response.user?.id || null;
+      } finally {
+        // Clean up the new user created in this test
+        if (newUserId) {
+          await TestUserManager.cleanupTestUser(client, testOrg, newUserId);
+        }
+      }
+    });
+
+    it('should throw error when email is missing', async () => {
+      const userData = TestDataGenerator.generateUserData({ email: '' }); // Empty email
+
+      await expect(
+        client.user.createUserAndMembership(testOrg, userData)
+      ).rejects.toThrow('email is required');
+    });
+
+    it('should throw error when organizationId is missing', async () => {
+      const userData = TestDataGenerator.generateUserData({ email: 'test@example.com' });
+
+      await expect(
+        client.user.createUserAndMembership('', userData)
+      ).rejects.toThrow('organizationId is required');
+    });
+  });
+
+  describe('updateUser', () => {
+    it('should update user', async () => {
+      // Modify the shared user
+      const updateData = TestDataGenerator.generateUserUpdateData();
+
+      const updatedUser = await client.user.updateUser(userId!, updateData);
+      
+      expect(updatedUser).toBeDefined();
+      expect(updatedUser.user).toBeDefined();
+      expect(updatedUser.user?.id).toBe(userId);
+      expect(updatedUser.user?.userProfile?.firstName).toBe('Updated');
+      expect(updatedUser.user?.userProfile?.lastName).toBe('Name');
+    });
+  });
+
+  describe('resendInvite', () => {
+    it('should resend invite to user', async () => {
+      // Resend invite to the shared user
+      const resendResponse = await client.user.resendInvite(testOrg, userId!);
+      
+      // Verify the response structure
+      expect(resendResponse).toBeDefined();
+      expect(resendResponse.invite).toBeDefined();
+      expect(resendResponse.invite?.userId).toBe(userId);
+      expect(resendResponse.invite?.organizationId).toBe(testOrg);
+      expect(resendResponse.invite?.status).toBe('PENDING_INVITE');
+      expect(resendResponse.invite?.createdAt).toBeDefined();
+      expect(resendResponse.invite?.expiresAt).toBeDefined();
+      expect(resendResponse.invite?.resentCount).toBe(1);
+    });
+
+    it('should throw error when organizationId is missing', async () => {
+      await expect(
+        client.user.resendInvite('', userId!)
+      ).rejects.toThrow('organizationId is required');
+    });
+
+    it('should throw error when userId is missing', async () => {
+      await expect(
+        client.user.resendInvite(testOrg, '')
+      ).rejects.toThrow('userId is required');
+    });
+  });
+}); 

package/tests/utils/test-data.ts

@@ -0,0 +1,248 @@
+import { CreateUserRequest, UpdateUserRequest } from '../../src/types/user';
+import { TemplateType } from '../../src/pkg/grpc/scalekit/v1/auth/passwordless_pb';
+
+/**
+ * Test data generation utilities to reduce redundancy across test files
+ */
+
+export class TestDataGenerator {
+  /**
+   * Generate a unique timestamp-based identifier
+   */
+  static generateUniqueId(): string {
+    return Date.now().toString();
+  }
+
+  /**
+   * Generate a unique email address for testing
+   */
+  static generateUniqueEmail(): string {
+    return `test.user.${this.generateUniqueId()}@example.com`;
+  }
+
+  /**
+   * Generate test organization data
+   */
+  static generateOrganizationData() {
+    const uniqueId = this.generateUniqueId();
+    return {
+      name: `Test Org ${uniqueId}`,
+      externalId: `ext_org_${uniqueId}`
+    };
+  }
+
+  /**
+   * Generate test user data
+   */
+  static generateUserData(overrides: Partial<CreateUserRequest> = {}): CreateUserRequest {
+    const uniqueEmail = this.generateUniqueEmail();
+    
+    return {
+      email: uniqueEmail,
+      userProfile: {
+        firstName: 'Test',
+        lastName: 'User'
+      },
+      metadata: {
+        source: 'test'
+      },
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test user update data
+   */
+  static generateUserUpdateData(overrides: Partial<UpdateUserRequest> = {}): UpdateUserRequest {
+    return {
+      userProfile: {
+        firstName: 'Updated',
+        lastName: 'Name'
+      },
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test passwordless email data
+   */
+  static generatePasswordlessEmailData(overrides: any = {}) {
+    return {
+      template: TemplateType.SIGNIN,
+      state: 'test-state',
+      expiresIn: 3600,
+      magiclinkAuthUri: 'https://example.com/auth/callback',
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test passwordless email with template variables
+   */
+  static generatePasswordlessEmailWithTemplateData(overrides: any = {}) {
+    return {
+      template: TemplateType.SIGNUP,
+      templateVariables: {
+        companyName: 'Test Company',
+        appName: 'Test App'
+      },
+      magiclinkAuthUri: 'https://example.com/auth/callback',
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test webhook data for verification
+   */
+  static generateWebhookData() {
+    const secret = 'whsec_test-secret';
+    const payload = '{"test": "data"}';
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const webhookId = 'msg_test_webhook_id';
+    
+    // Generate valid signature for testing
+    const crypto = require('crypto');
+    const data = `${webhookId}.${timestamp}.${payload}`;
+    const hmac = crypto.createHmac('sha256', Buffer.from('test-secret', 'base64'));
+    hmac.update(data);
+    const computedSignature = hmac.digest('base64');
+    const signature = `v1,${computedSignature}`;
+    
+    return {
+      secret,
+      payload,
+      timestamp,
+      webhookId,
+      signature,
+      headers: {
+        'webhook-id': webhookId,
+        'webhook-timestamp': timestamp,
+        'webhook-signature': signature
+      }
+    };
+  }
+
+  /**
+   * Generate test authorization URL options
+   */
+  static generateAuthorizationUrlOptions(overrides: any = {}) {
+    return {
+      scopes: ['openid', 'profile'],
+      state: 'test-state',
+      nonce: 'test-nonce',
+      prompt: 'login',
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test PKCE parameters
+   */
+  static generatePKCEParams() {
+    return {
+      codeChallenge: 'test-challenge',
+      codeChallengeMethod: 'S256'
+    };
+  }
+
+  /**
+   * Generate test pagination parameters
+   */
+  static generatePaginationParams(pageSize: number = 10) {
+    return {
+      pageSize,
+      pageToken: ''
+    };
+  }
+
+  /**
+   * Generate test credential data for passwordless verification
+   */
+  static generateCredentialData(type: 'code' | 'linkToken' = 'code') {
+    if (type === 'code') {
+      return { code: 'mock-code' };
+    } else {
+      return { linkToken: 'mock-link-token' };
+    }
+  }
+}
+
+/**
+ * Test organization management utilities
+ */
+export class TestOrganizationManager {
+  /**
+   * Create a test organization and return its ID
+   */
+  static async createTestOrganization(client: any): Promise<string> {
+    const orgData = TestDataGenerator.generateOrganizationData();
+    const orgResponse = await client.organization.createOrganization(
+      orgData.name, 
+      { externalId: orgData.externalId }
+    );
+    
+    const testOrg = orgResponse.organization?.id || '';
+    if (!testOrg) {
+      throw new Error('Failed to create test organization');
+    }
+    
+    return testOrg;
+  }
+
+  /**
+   * Clean up a test organization
+   */
+  static async cleanupTestOrganization(client: any, testOrg: string): Promise<void> {
+    if (testOrg) {
+      try {
+        await client.organization.deleteOrganization(testOrg);
+      } catch (error) {
+        // Organization may already be deleted
+      }
+    }
+  }
+}
+
+/**
+ * Test user management utilities
+ */
+export class TestUserManager {
+  /**
+   * Create a test user and return user data
+   */
+  static async createTestUser(client: any, testOrg: string, overrides: Partial<CreateUserRequest> = {}) {
+    const userData = TestDataGenerator.generateUserData(overrides);
+    const createResponse = await client.user.createUserAndMembership(testOrg, userData);
+    const createdUserId = createResponse.user?.id;
+    
+    if (!createdUserId) {
+      throw new Error('Failed to create test user');
+    }
+    
+    return {
+      userId: createdUserId,
+      userData,
+      response: createResponse
+    };
+  }
+
+  /**
+   * Clean up a test user
+   */
+  static async cleanupTestUser(client: any, testOrg: string, userId: string): Promise<void> {
+    if (userId) {
+      try {
+        // Remove membership if it exists
+        await client.user.deleteMembership(testOrg, userId);
+      } catch (error) {
+        // Membership may not exist
+      }
+      
+      try {
+        await client.user.deleteUser(userId);
+      } catch (error) {
+        // User may already be deleted
+      }
+    }
+  }
+}