boldsign 1.0.3 → 1.0.4

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/unit/brandingApi.spec.ts

@@ -0,0 +1,163 @@
+import { BrandingApi } from '../../api/brandingApi';
+import * as sinon from 'sinon';
+
+describe('BrandingApi Unit Test', () => {
+    let brandingApiStub: sinon.SinonStubbedInstance<BrandingApi>;
+
+    beforeEach(() => {
+        brandingApiStub = sinon.createStubInstance(BrandingApi);
+        brandingApiStub.createBrand = sinon.stub().resolves({ brandId: 'brand_id' });
+        brandingApiStub.updateBrand = sinon.stub().resolves({
+            success: true,
+            message: 'Brand updated successfully',
+        });
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should mock and verify createBrand call', async () => {
+        const mockBrandCreated = {
+            brandId: 'brand_id',
+        };
+
+        const brandData = {
+            brandName: "New Brand",
+            brandLogo: Buffer.from("mock_logo_data"),
+            backgroundColor: "#FFFFFF",
+            buttonColor: "#000000",
+            buttonTextColor: "#FFFFFF",
+            emailDisplayName: "Brand Email",
+            disclaimerDescription: "Disclaimer",
+            disclaimerTitle: "Disclaimer Title",
+            redirectUrl: "https://example.com",
+            redirectUri: "https://example.com",
+            isDefault: true,
+            canHideTagLine: false,
+            combineAuditTrail: true,
+            excludeAuditTrailFromEmail: false,
+            documentTimeZone: "UTC",
+            completedEmailType: "email_type",
+            emailSignedDocument: "email_signed_doc",
+            showBuiltInFormFields: true,
+            allowCustomFieldCreation: true,
+            showSharedCustomFields: true,
+            hideDecline: false,
+            hideSave: false
+        };
+
+        const result = await brandingApiStub.createBrand(brandData);
+
+        expect(result).toBeDefined();
+        expect(result.brandId).toBe('brand_id');
+
+        sinon.assert.calledOnceWithExactly(brandingApiStub.createBrand, brandData);
+    });
+
+    it('should mock and verify updateBrand call', async () => {
+        const mockBrandUpdated = {
+            success: true,
+            message: 'Brand updated successfully',
+        };
+
+        const brandId = 'brand_id';
+        const updatedBrandData = {
+            name: 'Updated Corporate Theme',
+            primaryColor: '#FF0000',
+        };
+        const result = await brandingApiStub.updateBrand(brandId, updatedBrandData);
+
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Brand updated successfully');
+
+        sinon.assert.calledOnceWithExactly(brandingApiStub.updateBrand, brandId, updatedBrandData);
+    });
+
+    it('should mock and verify listBrands call', async () => {
+        const mockBrandList = [
+            {
+                brandId: 'brand_1',
+                name: 'Brand One',
+                primaryColor: '#FF0000',
+            },
+            {
+                brandId: 'brand_2',
+                name: 'Brand Two',
+                primaryColor: '#00FF00',
+            },
+        ];
+
+        brandingApiStub.listBrands = sinon.stub().resolves(mockBrandList);
+
+        const result = await brandingApiStub.listBrands();
+
+        expect(result).toBeDefined();
+        expect(result.length).toBe(2);
+        expect(result[0].brandId).toBe('brand_1');
+        expect(result[0].name).toBe('Brand One');
+        expect(result[0].primaryColor).toBe('#FF0000');
+
+        sinon.assert.calledOnce(brandingApiStub.listBrands);
+    });
+
+    it('should mock and verify getBrand call', async () => {
+        const brandId = 'brand_1';
+        const mockBrandDetails = {
+            brandId: 'brand_1',
+            name: 'Brand One',
+            primaryColor: '#FF0000',
+            backgroundColor: '#FFFFFF',
+            brandLogoUrl: 'https://example.com/logo.png',
+        };
+
+        brandingApiStub.getBrand = sinon.stub().resolves(mockBrandDetails);
+
+        const result = await brandingApiStub.getBrand(brandId);
+
+        expect(result).toBeDefined();
+        expect(result.brandId).toBe('brand_1');
+        expect(result.name).toBe('Brand One');
+        expect(result.primaryColor).toBe('#FF0000');
+        expect(result.backgroundColor).toBe('#FFFFFF');
+        expect(result.brandLogoUrl).toBe('https://example.com/logo.png');
+
+        sinon.assert.calledOnceWithExactly(brandingApiStub.getBrand, brandId);
+    });
+
+    it('should mock and verify deleteBrand call', async () => {
+        const brandId = 'brand_1';
+
+        const mockDeleteResponse = {
+            success: true,
+            message: 'Brand deleted successfully',
+        };
+    
+        brandingApiStub.deleteBrand = sinon.stub().resolves(mockDeleteResponse);
+    
+        const result = await brandingApiStub.deleteBrand(brandId);
+    
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Brand deleted successfully');
+    
+        sinon.assert.calledOnceWithExactly(brandingApiStub.deleteBrand, brandId);
+    });
+
+    it('should mock and verify resetBrandSettingsToDefault call', async () => {
+        const brandId = 'brand_1';
+
+        const mockResetResponse = { success: true, message: 'Brand settings reset to default' };
+
+        brandingApiStub.resetBrandSettingsToDefault = sinon.stub().resolves(mockResetResponse);
+
+        const result = await brandingApiStub.resetBrandSettingsToDefault(brandId);
+
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Brand settings reset to default');
+
+        sinon.assert.calledOnceWithExactly(brandingApiStub.resetBrandSettingsToDefault, brandId);
+    });
+});

package/tests/unit/contactsApi.spec.ts

@@ -0,0 +1,143 @@
+import { ContactsApi } from '../../api/contactsApi';
+import * as sinon from 'sinon';
+
+describe('ContactApi Unit Test', () => {
+    let contactApiStub: sinon.SinonStubbedInstance<ContactsApi>;
+
+    beforeEach(() => {
+        // Create a stub instance for the ContactApi
+        contactApiStub = sinon.createStubInstance(ContactsApi);
+
+        contactApiStub.createContact = sinon.stub().resolves({ contactId: 'contact_id' });
+        contactApiStub.updateContact = sinon.stub().resolves({
+            success: true,
+            message: 'Contact updated successfully',
+        });
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should mock and verify createContact call', async () => {
+        const mockContactCreated = {
+            contactId: 'contact_id',
+        };
+
+        const contactData = {
+            name: 'New contact',
+            email: 'newEmail@gmail.com',
+            phoneNumber: '9876543210',
+            jobTitle: 'Test',
+            companyName: 'Syncfusion',
+        };
+
+        contactApiStub.createContact.resolves(mockContactCreated);
+
+        const result = await contactApiStub.createContact(contactData);
+
+        expect(result).toBeDefined();
+        expect(result.contactId).toBe('contact_id');
+
+        sinon.assert.calledOnceWithExactly(contactApiStub.createContact, contactData);
+    });
+
+    it('should mock and verify listContacts call', async () => {
+        const mockContactList = [
+            {
+                contactId: 'contact_1',
+                name: 'Contact One',
+                email: 'contact1@example.com',
+            },
+            {
+                contactId: 'contact_2',
+                name: 'Contact Two',
+                email: 'contact2@example.com',
+            },
+        ];
+    
+        contactApiStub.listContacts = sinon.stub().resolves(mockContactList);
+    
+        const result = await contactApiStub.listContacts();
+    
+        expect(result).toBeDefined();
+        expect(result.length).toBe(2);
+        expect(result[0].contactId).toBe('contact_1');
+        expect(result[0].name).toBe('Contact One');
+        expect(result[0].email).toBe('contact1@example.com');
+    
+        sinon.assert.calledOnce(contactApiStub.listContacts);
+    });
+
+    it('should mock and verify updateContact call', async () => {
+        const mockUpdatedContact = {
+            success: true,
+            message: 'Contact updated successfully',
+        };
+    
+        const contactId = 'contact_1';
+        const updatedContactData = {
+            name: 'Updated Contact One',
+            email: 'updatedEmail@example.com',
+            phoneNumber: '1234567890',
+            jobTitle: 'Updated Job Title',
+            companyName: 'Updated Company',
+        };
+    
+        contactApiStub.updateContact = sinon.stub().resolves(mockUpdatedContact);
+    
+        const result = await contactApiStub.updateContact(contactId, updatedContactData);
+    
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Contact updated successfully');
+    
+        sinon.assert.calledOnceWithExactly(contactApiStub.updateContact, contactId, updatedContactData);
+    });
+
+    it('should mock and verify deleteContact call', async () => {
+        const mockDeleteResponse = {
+            success: true,
+            message: 'Contact deleted successfully',
+        };
+    
+        const contactId = 'contact_1';
+    
+        contactApiStub.deleteContact = sinon.stub().resolves(mockDeleteResponse);
+    
+        const result = await contactApiStub.deleteContact(contactId);
+    
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Contact deleted successfully');
+    
+        sinon.assert.calledOnceWithExactly(contactApiStub.deleteContact, contactId);
+    });
+    
+    it('should mock and verify getContact call', async () => {
+        const mockContactDetails = {
+            contactId: 'contact_1',
+            name: 'Contact One',
+            email: 'contact1@example.com',
+            phoneNumber: '9876543210',
+            jobTitle: 'Software Engineer',
+            companyName: 'TechCorp',
+        };
+    
+        const contactId = 'contact_1';
+    
+        contactApiStub.getContact = sinon.stub().resolves(mockContactDetails);
+    
+        const result = await contactApiStub.getContact(contactId);
+    
+        expect(result).toBeDefined();
+        expect(result.contactId).toBe('contact_1');
+        expect(result.name).toBe('Contact One');
+        expect(result.email).toBe('contact1@example.com');
+        expect(result.phoneNumber).toBe('9876543210');
+        expect(result.jobTitle).toBe('Software Engineer');
+        expect(result.companyName).toBe('TechCorp');
+    
+        sinon.assert.calledOnceWithExactly(contactApiStub.getContact, contactId);
+    });
+});

package/tests/unit/customFieldApi.spec.ts

@@ -0,0 +1,123 @@
+import { CustomFieldApi } from '../../api/customFieldApi';
+import * as sinon from 'sinon';
+
+describe('CustomFieldsApi Unit Test', () => {
+    let customFieldsApiStub: sinon.SinonStubbedInstance<CustomFieldApi>;
+
+    beforeEach(() => {
+        customFieldsApiStub = sinon.createStubInstance(CustomFieldApi);
+
+        // Create a plain object stub with required methods manually
+        customFieldsApiStub.createCustomField = sinon.stub().resolves({ customFieldId: 'field_id' });
+        customFieldsApiStub.updateCustomField = sinon.stub().resolves({
+            success: true,
+            message: 'Custom field updated successfully',
+        });
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should mock and verify createCustomField call', async () => {
+        const customFieldData = {
+            name: 'Employee ID',
+            type: 'text',
+            required: true,
+            defaultValue: '12345',
+        };
+
+        const result = await customFieldsApiStub.createCustomField(customFieldData);
+
+        expect(result).toBeDefined();
+        expect(result.customFieldId).toBe('field_id');
+
+        sinon.assert.calledOnceWithExactly(customFieldsApiStub.createCustomField, customFieldData);
+    });
+
+    it('should mock and verify updateCustomField call', async () => {
+        const customFieldId = 'field_id';
+        const updatedFieldData = {
+            name: 'Updated Employee ID',
+            type: 'text',
+            required: false,
+            defaultValue: '00000',
+        };
+
+        const result = await customFieldsApiStub.updateCustomField(customFieldId, updatedFieldData);
+
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Custom field updated successfully');
+
+        sinon.assert.calledOnceWithExactly(customFieldsApiStub.updateCustomField, customFieldId, updatedFieldData);
+    });
+
+    it('should mock and verify listCustomFields call', async () => {
+        const mockCustomFieldList = [
+            {
+                customFieldId: 'field_1',
+                name: 'Employee ID',
+                type: 'text',
+                required: true,
+                defaultValue: '12345',
+            },
+            {
+                customFieldId: 'field_2',
+                name: 'Department',
+                type: 'select',
+                required: false,
+                defaultValue: 'HR',
+            },
+        ];
+
+        customFieldsApiStub.listCustomFields = sinon.stub().resolves(mockCustomFieldList);
+
+        const result = await customFieldsApiStub.listCustomFields();
+
+        expect(result).toBeDefined();
+        expect(result.length).toBe(2);
+        expect(result[0].customFieldId).toBe('field_1');
+        expect(result[0].name).toBe('Employee ID');
+        expect(result[1].customFieldId).toBe('field_2');
+        expect(result[1].name).toBe('Department');
+
+        sinon.assert.calledOnce(customFieldsApiStub.listCustomFields);
+    });
+
+    it('should mock and verify deleteCustomField call', async () => {
+        const mockDeleteResponse = {
+            success: true,
+            message: 'Custom field deleted successfully',
+        };
+
+        const customFieldId = 'field_1';
+
+        customFieldsApiStub.deleteCustomField = sinon.stub().resolves(mockDeleteResponse);
+
+        const result = await customFieldsApiStub.deleteCustomField(customFieldId);
+
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.message).toBe('Custom field deleted successfully');
+
+        sinon.assert.calledOnceWithExactly(customFieldsApiStub.deleteCustomField, customFieldId);
+    });
+
+    it('should mock and verify createEmbeddedCustomFieldUrl call', async () => {
+        const customFieldId = 'field_id';
+
+        const mockEmbeddedUrlResponse = {
+            success: true,
+            url: 'https://example.com/embedded/customfield/field_id',
+        };
+        customFieldsApiStub.createEmbeddedCustomFieldUrl = sinon.stub().resolves(mockEmbeddedUrlResponse);
+        const result = await customFieldsApiStub.createEmbeddedCustomFieldUrl(customFieldId);
+
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.url).toBe('https://example.com/embedded/customfield/field_id');
+
+        sinon.assert.calledOnceWithExactly(customFieldsApiStub.createEmbeddedCustomFieldUrl, customFieldId);
+    });
+});