boldsign 1.0.3 → 2.0.0

package/tests/integration/usersApiTest.spec.ts

@@ -0,0 +1,251 @@
+import { UserApi } from '../../api/userApi';
+import { CreateUser } from '../../model';
+import config from '../config';
+
+describe('UsersTestcase', () => {
+  let usersApi:UserApi;
+  let createdUserId:any
+  let emailId:any
+  const generateRandomEmail = () => {
+    const randomNum = Math.floor(1000 + Math.random() * 9000); 
+    return `sdktesting${randomNum}@syncfusion.com`;
+  };
+  beforeAll(() => {
+    createdUserId = null;
+    emailId = null;
+    const apiKey = config.apiKey;
+    const baseUrl = config.baseUrl;
+    if (!baseUrl || !apiKey) {
+      throw new Error("Environment variables 'HOST_URL' or 'API_KEY' are not set.");
+    }
+    usersApi = new UserApi(baseUrl);
+    usersApi.setApiKey(apiKey);
+    emailId = generateRandomEmail();
+    console.log(`Generated email: ${emailId}`);
+  });
+test('Test1:should create user successfully', async () => {
+    const createUserRequest = new CreateUser();
+    createUserRequest.emailId = emailId;
+    createUserRequest.userRole = CreateUser.UserRoleEnum.Member;
+    try {
+        const response = await usersApi.createUser([createUserRequest]);
+        console.log("User created successfully:", response);
+        console.log("Created User ID:", createdUserId);
+        expect(response).toBeDefined();
+      } catch (error:any) {
+        console.error("Error occurred while calling the API:", error.message);
+        expect(error.message).toBeUndefined();
+      }
+  },20000);
+  test('Test2:should retrieve list of users successfully', async () => {
+    const page = 1;
+    const pageSize = 20;
+    const search = emailId;
+    try {
+      const response = await usersApi.listUsers(page, pageSize, search);
+      console.log('Users list retrieved successfully:', response);
+      const usersList = response?.result; 
+      if (Array.isArray(usersList)) { 
+        for (let user of usersList) {
+          if (user.email === emailId) {
+            createdUserId = String(user.userId);
+            console.log("TestUserID: " + createdUserId);
+            break;
+          }
+        }
+      } else {
+        console.error('Users list is not available or not an array.');
+        throw new Error('Users list is invalid.');
+      }
+      expect(response).toBeDefined();
+      console.log("Created User ID:", createdUserId);
+    } catch (error:any) {
+      console.error('Error occurred while retrieving users:', error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },20000);
+  test('Test3:should fail to retrieve list of users with negative parameters', async () => {
+    const page = -1;
+    const pageSize = -10;
+    const search = '';
+    try {
+      await usersApi.listUsers(page, pageSize, search);
+      throw new Error('Expected API to fail with invalid parameters');
+    } catch (error: any) {
+      console.error('Error occurred while retrieving users:', error.message);
+      expect(error.message).toBeDefined(); 
+    }
+  },20000);
+  test('Test4:should fail to retrieve list of users with exceeded parameters', async () => {
+    const page = 100;
+    const pageSize = 10000;
+    const search = '';
+    try {
+      await usersApi.listUsers(page, pageSize, search);
+      throw new Error('Expected API to fail with invalid parameters');
+    } catch (error: any) {
+      console.error('Error occurred while retrieving users:', error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+  test('Test5:should return error while create user when invalid email is provided', async () => {
+    const createUserRequest = new CreateUser();
+    createUserRequest.emailId = "INVALID_EMAIL";
+    try {
+      await usersApi.createUser([createUserRequest]);
+      throw new Error('Expected ApiException to be thrown due to invalid email ID');
+    } catch (error:any) {
+      console.log("Expected error occurred: " + error.message);
+      expect(error.message).toBeDefined(); 
+    }
+  },20000);
+  test('Test6:should return error while create user when empty email ID is provided', async () => {
+    const createUserRequest = new CreateUser();
+    createUserRequest.emailId = "";
+    try {
+      await usersApi.createUser([createUserRequest]);
+      throw new Error("Expected API exception due to empty email ID");
+    } catch (error:any) {
+      console.log("Expected error occurred");
+      expect(error.message).toBeDefined(); 
+    }
+  },20000);
+  test('Test7:should return error while create user when already existing email is provided', async () => {
+    const createUserRequest = new CreateUser();
+    createUserRequest.emailId = emailId;
+    try {
+      await usersApi.createUser([createUserRequest]);
+      throw new Error("Expected API exception due to empty email ID");
+    } catch (error:any) {
+      console.log("Expected error occurred");
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+  test('Test8:should return error while update user when invalid user ID is provided', async () => {
+    const updateUserRequest = {
+      userId: "INVALID_USERID"
+    };
+    try {
+      await usersApi.updateUser(updateUserRequest);
+      throw new Error('Expected error due to invalid user ID');
+    } catch (error:any) {
+      console.log('Expected error occurred: ' + error.message);
+      expect(error.message).toBeDefined(); 
+    }
+  },20000);
+  test('Test9:should retrieve user successfully', async () => {
+    try {
+      const response = await usersApi.getUser(createdUserId);
+      console.log('User retrieved successfully:', response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.error("Error occurred while retrieving the user:", error.message);
+    }  
+  },20000);
+  test('Test10:should return error while retrive user when invalid userId is provided', async () => {
+    const userId = "INVALID_USERID";
+    try {
+      await usersApi.getUser(userId);
+      throw new Error("Expected error due to invalid userId");
+    } catch (error:any) {
+      console.log("Expected error occurred: " + error.message);
+      expect(error.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+  test('Test11:should return error while retrive user when user id is empty', async () => {
+    const userId = "";
+    try {
+      await usersApi.getUser(userId);
+      throw new Error("Expected error due to invalid userId");
+    } catch (error:any) {
+      console.log("Expected error occurred: " + error.message);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+  test('Test12:should return error while retrive user when invalid userId is provided', async () => {
+    const userId = "INVALID_USERID";
+    console.log("TestUserID: " + userId);
+    try {
+      await usersApi.getUser(userId);
+      throw new Error("Expected error due to invalid userId");
+    } catch (error:any) {
+      console.log("Expected error occurred: " + error.message);
+      expect(error.message).toBeDefined(); 
+    }
+  },20000);
+  test('Test13: should resend invitation successfully', async () => {
+    try {
+      const response = await usersApi.resendInvitation(createdUserId);
+      expect(response).toBeDefined(); 
+      console.log('Invitation resent successfully!');
+    } catch (error: any) {
+      console.error('Error occurred while resending the invitation:', error.message);
+      throw new Error('Invitation resend failed');
+    }
+  },20000);
+  test('Test14:should fail to resend invitation with invalid user ID', async () => {
+    const userId = "INVALID_USERID";
+    try {
+      await usersApi.resendInvitation(userId);
+      throw new Error('Expected API to fail due to invalid user ID');
+    } catch (error:any) {
+      console.error('Error occurred while resending the invitation:', error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test15:should fail to resend invitation when user id is empty', async () => {
+    const userId = "";
+    try {
+      await usersApi.resendInvitation(userId);
+      throw new Error('Expected API to fail due to invalid user ID');
+    } catch (error:any) {
+      console.error('Error occurred while resending the invitation:', error);
+      expect(error).toBeDefined();
+      expect(error.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+  test('Test16: should cancel invitation successfully', async () => {
+    try {
+      const response = await usersApi.cancelInvitation(createdUserId);
+      expect(response).toBeDefined(); 
+      console.log('Invitation canceled successfully!');
+    } catch (error: any) {
+      console.error('Error occurred while canceling the invitation:', error.message);
+      expect(error.message).toBeUndefined();
+    }
+  },2000);
+  test('Test17:should fail to cancel invitation due to invalid userId', async () => {
+    const userId = "INVALID_USERID";
+    try {
+      await usersApi.cancelInvitation(userId);
+      console.error('Unexpected success. Invitation should not have been canceled.');
+      throw new Error('Test failed: Invitation should not have been canceled');
+    } catch (error:any) {
+      console.error('Expected error occurred while canceling the invitation:', error.message);
+      expect(error.message).toBeDefined();
+    }
+  },20000);
+  test('Test18:should fail to cancel invitation due to empty userId', async () => {
+    const userId = "";
+    try {
+      await usersApi.cancelInvitation(userId);
+      console.error('Unexpected success. Invitation should not have been canceled.');
+      throw new Error('Test failed: Invitation should not have been canceled');
+    } catch (error:any) {
+      console.error('Expected error occurred while canceling the invitation', error);
+      expect(error).toBeDefined();
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  },20000);
+});

package/tests/performance/performanceApiTest.spec.ts

@@ -0,0 +1,362 @@
+import {BrandingApi,ContactsApi,CustomFieldApi,DocumentApi,TemplateApi,SenderIdentitiesApi,TeamsApi,UserApi} from '../../api';
+import {ContactDetails,BrandCustomFieldDetails,CustomFormField,DocumentSigner,FormField,Rectangle,SendForSign,AuthenticationSettings,CreateTemplateRequest,TemplateRole,Role,SendForSignFromTemplateForm,ReminderSettings,CreateSenderIdentityRequest,CreateTeamRequest,CreateUser} from '../../model';
+import config from '../config';
+import * as fs from 'fs';
+import { performance } from 'perf_hooks';
+
+describe('Full Integration & Performance Test Suite', () => {
+  let senderIdentitiesApi:SenderIdentitiesApi;
+  let brandingApi: BrandingApi;
+  let contactsApi: ContactsApi;
+  let customFieldApi: CustomFieldApi;
+  let documentApi: DocumentApi;
+  let templateApi: TemplateApi;
+  let teamsApi: TeamsApi;
+  let userApi:UserApi;
+
+  let brandId;
+  let createdUserId;
+  let teamName;
+  let createdCustomFieldId;
+  let createdSenderIdentityId;
+  let createdDocumentId;
+  let createdTemplateId;
+  let emailId;
+  let customFieldName;
+
+  const generateRandomEmail = () => `sdktesting${Math.floor(1000 + Math.random() * 9000)}@syncfusion.com`;
+  const generateRandomNumber = () => Math.floor(1000 + Math.random() * 9000).toString();
+
+  beforeAll(() => {
+    const apiKey = config.apiKey;
+    const baseUrl = config.baseUrl;
+
+    if (!apiKey || !baseUrl) {
+      throw new Error("Environment variables 'API_KEY' or 'HOST_URL' are not set.");
+    }
+
+    brandingApi = new BrandingApi(baseUrl);
+    brandingApi.setApiKey(apiKey);
+
+    contactsApi = new ContactsApi(baseUrl);
+    contactsApi.setApiKey(apiKey);
+
+    customFieldApi = new CustomFieldApi(baseUrl);
+    customFieldApi.setApiKey(apiKey);
+
+    documentApi = new DocumentApi(baseUrl);
+    documentApi.setApiKey(apiKey);
+
+    templateApi = new TemplateApi(baseUrl);
+    templateApi.setApiKey(apiKey);
+
+    senderIdentitiesApi =new SenderIdentitiesApi(baseUrl);
+    senderIdentitiesApi.setApiKey(apiKey);
+
+    teamsApi = new TeamsApi(baseUrl);
+    teamsApi.setApiKey(apiKey);
+
+    userApi = new UserApi(baseUrl);
+    userApi.setApiKey(apiKey);
+
+    emailId = generateRandomEmail();
+    customFieldName = `Test Custom Field ${generateRandomNumber()}`;
+    teamName = `sdktestingteam${generateRandomNumber()}`;
+  });
+
+  test('Performance Test 1: Create a brand', async () => {
+    const brandLogo = fs.createReadStream("tests/documents/logo.jpg");
+
+    const start = performance.now();
+    try {
+      const response = await brandingApi.createBrand(
+        "NodeSDK_Perf",
+        brandLogo,
+        "Blue",
+        "Black",
+        "White",
+        "{SenderName} from Syncfusion"
+      );
+      const end = performance.now();
+      const duration = end - start;
+
+      console.log(`Brand creation took ${duration.toFixed(10)} ms`);
+      brandId = response.brandId;
+
+      expect(brandId).toBeDefined();
+      expect(duration).toBeLessThan(10000);
+    } catch (error: any) {
+      console.error("Error during brand creation:", error.message);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+
+  test('Performance Test 2: Create a contact', async () => {
+    const contactDetails = new ContactDetails();
+    contactDetails.name = "sdktesting";
+    contactDetails.email = emailId;
+
+    const start = performance.now();
+    try {
+      const response = await contactsApi.createContact([contactDetails]);
+      const end = performance.now();
+      const duration = end - start;
+
+      console.log(`Contact creationcontac took ${duration.toFixed(10)} ms`);
+
+      expect(response).toBeDefined();
+      expect(duration).toBeLessThan(10000);
+    } catch (error) {
+      console.error("Error during contact creation:", error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+
+  test('Performance Test 3: Create a custom field', async () => {
+    const formField = new CustomFormField();
+    formField.fieldType = CustomFormField.FieldTypeEnum.Signature;
+    formField.placeHolder = "string";
+    formField.isRequired = true;
+
+    const customFieldDetails = new BrandCustomFieldDetails();
+    customFieldDetails.fieldName = customFieldName;
+    customFieldDetails.fieldDescription = "string";
+    customFieldDetails.fieldOrder = 2;
+    customFieldDetails.brandId = brandId;
+    customFieldDetails.sharedField = true;
+    customFieldDetails.formField = formField;
+
+    const start = performance.now();
+    try {
+      const response = await customFieldApi.createCustomField(customFieldDetails);
+      const end = performance.now();
+      const duration = end - start;
+
+      console.log(`Custom field creation took ${duration.toFixed(10)} ms`);
+      createdCustomFieldId = response.customFieldId;
+
+      expect(createdCustomFieldId).toBeDefined();
+      expect(duration).toBeLessThan(10000);
+    } catch (error: any) {
+      console.error("Error during custom field creation:", error.message);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+
+  test('Performance Test 4: Send document for signing', async () => {
+    const signer = new DocumentSigner();
+    signer.name = 'Test Signer';
+    signer.emailAddress = 'mohammedmushraf.abuthakir+6@syncfusion.com';
+    signer.signerOrder = 1;
+    signer.signerType = DocumentSigner.SignerTypeEnum.Signer;
+    signer.authenticationType = DocumentSigner.AuthenticationTypeEnum.AccessCode;
+    signer.authenticationCode = '123456';
+    signer.authenticationSettings = {
+      authenticationFrequency: AuthenticationSettings.AuthenticationFrequencyEnum.EveryAccess
+    };
+
+    const formField = new FormField();
+    formField.name = 'Sign';
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.font = FormField.FontEnum.Helvetica;
+    formField.pageNumber = 1;
+    formField.isRequired = true;
+    formField.bounds = new Rectangle();
+
+    signer.formFields = [formField];
+    signer.privateMessage = 'This is a private message for signer';
+
+    const sendRequest = new SendForSign();
+    sendRequest.title = 'Document SDK API';
+    sendRequest.files = [fs.createReadStream('tests/documents/agreement.pdf')];
+    sendRequest.enablePrintAndSign = true;
+    sendRequest.signers = [signer];
+    sendRequest.message = 'Please sign this document';
+
+    const start = performance.now();
+    try {
+      const response = await documentApi.sendDocument(sendRequest);
+      const end = performance.now();
+      const duration = end - start;
+
+      console.log(`Document sending took ${duration.toFixed(10)} ms`);
+      createdDocumentId = response.documentId;
+
+      expect(createdDocumentId).toBeDefined();
+      expect(duration).toBeLessThan(10000);
+    } catch (error) {
+      console.error("Error during document sending:", error);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+
+  test('Performance Test 5: Create a template', async () => {
+    const signatureField = new FormField();
+    signatureField.fieldType = FormField.FieldTypeEnum.Signature;
+    signatureField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 50;
+    bounds.y = 100;
+    bounds.width = 150;
+    bounds.height = 50;
+    signatureField.bounds = bounds;
+
+    const role = new TemplateRole();
+    role.index = 1;
+    role.name = "Signer";
+    role.defaultSignerName = "John Doe";
+    role.defaultSignerEmail = "johndoe@example.com";
+    role.signerOrder = 1;
+    role.signerType = TemplateRole.SignerTypeEnum.Signer;
+    role.formFields = [signatureField];
+
+    const createTemplateRequest = new CreateTemplateRequest();
+    createTemplateRequest.title = "Testing node sdk";
+    createTemplateRequest.description = "Testing integration test case";
+    createTemplateRequest.documentTitle = "Node sdk test case";
+    createTemplateRequest.documentMessage = "Please check and sign";
+    createTemplateRequest.roles = [role];
+    createTemplateRequest.enableReassign = true;
+    createTemplateRequest.enableSigningOrder = true;
+    createTemplateRequest.allowNewRoles = true;
+    createTemplateRequest.allowMessageEditing = true;
+    createTemplateRequest.allowNewFiles = true;
+    createTemplateRequest.files = [fs.createReadStream("tests/documents/agreement.pdf")];
+
+    const start = performance.now();
+    try {
+      const response = await templateApi.createTemplate(createTemplateRequest);
+      const end = performance.now();
+      const duration = end - start;
+
+      console.log(`Template creation took ${duration.toFixed(10)} ms`);
+      createdTemplateId = response.templateId;
+
+      expect(createdTemplateId).toBeDefined();
+      expect(duration).toBeLessThan(10000);
+    } catch (error: any) {
+      console.error("Error during template creation:", error.message);
+      expect(error).toBeUndefined();
+    }
+  }, 20000);
+
+test('Performanc Test 6: should send document for signing using template', async () => {
+    const start = performance.now();
+    const formField = new FormField();
+    formField.fieldType = FormField.FieldTypeEnum.Signature;
+    formField.pageNumber = 1;
+    const bounds = new Rectangle();
+    bounds.x = 100;
+    bounds.y = 50;
+    bounds.width = 100;
+    bounds.height = 100;
+    formField.bounds = bounds;
+    const role = new Role();
+    role.roleIndex = 50;
+    role.signerName = "Divya";
+    role.signerEmail = "divya.boopathy+20@syncfusion.com";
+    role.signerOrder = 1;
+    role.enableEmailOTP = false;
+    role.signerType = Role.SignerTypeEnum.Signer;
+    role.authenticationType = Role.AuthenticationTypeEnum.AccessCode;
+    role.authenticationCode = '123456';
+    role.authenticationSettings = {
+            authenticationFrequency: AuthenticationSettings.AuthenticationFrequencyEnum.EveryAccess
+        };
+    role.signerRole = "Manager";
+    role.privateMessage = "Please check and sign the document";
+    role.formFields = [formField];
+    const sendForSignFromTemplate = new SendForSignFromTemplateForm();
+    const files = fs.createReadStream("tests/documents/agreement.pdf");
+    sendForSignFromTemplate.files = [files];
+    sendForSignFromTemplate.title = "Invitation form";
+    sendForSignFromTemplate.message = "Kindly review and sign this.";
+    sendForSignFromTemplate.roles = [role];
+    sendForSignFromTemplate.disableEmails = false;
+    sendForSignFromTemplate.disableSMS = false;
+    sendForSignFromTemplate.hideDocumentId = true;
+    sendForSignFromTemplate.labels = ["Invitation", "Form", "Test"];
+    const reminderSettings = new ReminderSettings();
+    reminderSettings.reminderDays = 3;
+    reminderSettings.reminderCount = 5;
+    reminderSettings.enableAutoReminder = false;
+    sendForSignFromTemplate.reminderSettings = reminderSettings;
+    sendForSignFromTemplate.expiryValue = 60;
+    sendForSignFromTemplate.disableExpiryAlert = true;
+    sendForSignFromTemplate.enablePrintAndSign = true;
+    sendForSignFromTemplate.enableReassign = true;
+    sendForSignFromTemplate.enableSigningOrder = true;
+    try {
+      const response = await templateApi.sendUsingTemplate(createdTemplateId, sendForSignFromTemplate);
+      const end = performance.now();
+      const duration = end - start;
+      console.log(`Send document from template took ${duration.toFixed(10)} ms`);
+      expect(duration).toBeLessThan(10000);
+      console.log("Document sent for signing using template successfully:", response);
+      expect(response).toBeDefined();
+    } catch (error:any) {
+      console.error("Error occurred while calling the API:", error.message);
+      expect(error.message).toBeUndefined();
+    }
+  }, 20000);
+
+  test('Performance Test 7: should create sender identity successfully', async () => {
+      const start = performance.now();
+      const createSenderIdentityRequest = new CreateSenderIdentityRequest();
+      createSenderIdentityRequest.name = "SenderIdentity API";
+      createSenderIdentityRequest.email = emailId;
+      createSenderIdentityRequest.redirectUrl = "https://boldsign.com";
+      try {
+        const response = await senderIdentitiesApi.createSenderIdentities(createSenderIdentityRequest);
+        console.log("Sender Identity created successfully:", response);
+        createdSenderIdentityId = response;
+        console.log("Created Sender Identity ID:", createdSenderIdentityId);
+        const end = performance.now();
+        const duration = end - start;
+        console.log(`Sender Identity creation took ${duration.toFixed(10)} ms`);
+        expect(duration).toBeLessThan(10000);
+        expect(response).toBeDefined();
+      } catch (error:any) {
+        console.log("Error occurred while calling the API:", error.message);
+        expect(error.message).toBeUndefined();
+      }
+    },20000);
+
+  test('Performance test 8: should create team successfully', async () => {
+      const start = performance.now();
+      const createTeamRequest = new CreateTeamRequest();
+      createTeamRequest.teamName = teamName;
+      try {
+          const createTeamResponse = await teamsApi.createTeam(createTeamRequest);
+          console.log('Team created successfully:', createTeamResponse);
+          const end = performance.now();
+          const duration = end - start;
+          console.log(`Teams creation took ${duration.toFixed(10)} ms`);
+          expect(duration).toBeLessThan(10000);
+          expect(createTeamResponse).toBeDefined();
+      } catch (error:any) {
+          console.error('Error occurred while creating team:', error.message);
+          expect(error.message).toBeUndefined();
+      }
+  },20000);
+
+  test('Performance test 9:should create user successfully', async () => {
+      const start = performance.now();
+      const createUserRequest = new CreateUser();
+      createUserRequest.emailId = emailId;
+      createUserRequest.userRole = CreateUser.UserRoleEnum.Member;
+      try {
+          const response = await userApi.createUser([createUserRequest]);
+          console.log("User created successfully:", response);
+          console.log("Created User ID:", createdUserId);
+          const end = performance.now();
+          const duration = end - start;
+          console.log(`User creation took ${duration.toFixed(10)} ms`);
+          expect(duration).toBeLessThan(10000);
+          expect(response).toBeDefined();
+        } catch (error:any) {
+          console.error("Error occurred while calling the API:", error.message);
+          expect(error.message).toBeUndefined();
+        }
+    },20000);
+});