boldsign 1.0.0-beta.1

package/tests/integration/CustomFieldApiTest.spec.ts

@@ -0,0 +1,209 @@
+import { CustomFieldApi } from '../../api/customFieldApi'; 
+import { BrandingApi } from '../../api/brandingApi'; 
+import {BrandCustomFieldDetails, CustomFormField } from '../../model'; 
+import * as fs from 'fs';
+
+describe('Custom Field API Test Suite', () => {
+  let customFieldApi;
+  let brandingApi;
+  let CreatedCustomFieldId;
+  let customFieldName;
+  let brandId;
+  const generateRandomNumber = () => {
+    const randomNum = Math.floor(1000 + Math.random() * 9000); 
+    return randomNum.toString();
+  };
+  beforeAll(() => {
+    brandId = null;
+    CreatedCustomFieldId = null;
+    customFieldName = null;
+    const baseUrl = process.env.HOST_URL;  
+    const apiKey = process.env.API_KEY;    
+    if (!baseUrl || !apiKey) {
+      throw new Error("Environment variables 'HOST_URL' or 'API_KEY' are not set.");
+    }
+    customFieldApi = new CustomFieldApi(baseUrl);
+    customFieldApi.setApiKey(apiKey);              
+    brandingApi = new BrandingApi(baseUrl);       
+    brandingApi.setApiKey(apiKey);                
+    customFieldName = `Test Custom Field${generateRandomNumber()}`;  
+    console.log(`Generated custom field name: ${customFieldName}`);
+  });
+    test('Test1:should create a brand successfully', async () => {
+      const brandName = "NodeSDK";
+      const brandLogo = fs.createReadStream("tests/integration/documents/Logo.png");
+      const backgroundColor = "Blue";
+      const buttonColor = "Black";
+      const buttonTextColor = "White";
+      const emailDisplayName = "{SenderName} from Syncfusion";
+      try {
+        const createBrandApiResponse = await brandingApi.createBrand(brandName, brandLogo, backgroundColor, buttonColor, buttonTextColor, emailDisplayName);
+        console.log("Brand created successfully:", createBrandApiResponse.body.brandId);
+        brandId = createBrandApiResponse.body.brandId;
+        expect(brandId).toBeDefined();
+        expect(brandId).toBeGreaterThan(0);
+      } catch (error) {
+        console.log("Error occurred while creating the brand:", error);
+      }
+    });
+  test('Test2: should create a custom field successfully', async () => {
+    const formField = new CustomFormField();
+    formField.fieldType = CustomFormField.FieldTypeEnum.Signature;
+    formField.placeHolder = "string";
+    formField.isRequired = true;
+    const customFieldDetails = new BrandCustomFieldDetails();
+    customFieldDetails.fieldName = "nodesdk1";
+    customFieldDetails.fieldDescription = "string";
+    customFieldDetails.fieldOrder = 2;
+    customFieldDetails.brandId = brandId; 
+    customFieldDetails.sharedField = true;
+    customFieldDetails.formField = formField;
+    try {
+      const createCustomFieldResponse = await customFieldApi.createCustomField(customFieldDetails);
+      console.log("Custom field created successfully:", createCustomFieldResponse.body);
+      CreatedCustomFieldId = createCustomFieldResponse.body.customFieldId;
+      console.log("Created Custom Field ID:", CreatedCustomFieldId);
+      expect(createCustomFieldResponse.body).toBeDefined();
+      expect(CreatedCustomFieldId).toBeDefined();
+      expect(CreatedCustomFieldId).toBeGreaterThan(0);
+    } catch (error) {
+      console.log("Error occurred while calling the API:", error);
+    }
+  });
+  test('Test3:should fail to create a custom field with invalid brandId', async () => {
+    const formField = new CustomFormField();
+    formField.fieldType = CustomFormField.FieldTypeEnum.Signature;
+    formField.placeHolder = "string";
+    formField.isRequired = true;
+    const customFieldDetails = new BrandCustomFieldDetails();
+    customFieldDetails.fieldName = "nodesdk12";
+    customFieldDetails.fieldDescription = "string";
+    customFieldDetails.fieldOrder = 2;
+    customFieldDetails.brandId = "invalid-brand-id";  
+    customFieldDetails.sharedField = true;
+    customFieldDetails.formField = formField;
+    try {
+      const createCustomFieldResponse = await customFieldApi.createCustomField(customFieldDetails);
+      console.log("Custom field created successfully:", createCustomFieldResponse);
+      expect(createCustomFieldResponse).toBeDefined();
+      expect(createCustomFieldResponse.body).toHaveProperty('id');  
+      expect(createCustomFieldResponse.body.id).not.toBeNull();  
+      expect(createCustomFieldResponse.body.fieldName).toBe(customFieldDetails.fieldName);
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      expect(error).toBeDefined();  
+    }
+  });
+  test('Test4:should update a custom field successfully', async () => {
+    console.log(CreatedCustomFieldId);
+    const formField = new CustomFormField();
+    formField.fieldType = CustomFormField.FieldTypeEnum.Signature;
+    formField.placeHolder = "new_placeholder";
+    formField.isRequired = true;
+    const customFieldDetails = new BrandCustomFieldDetails();
+    customFieldDetails.fieldName = "Updated Nodesdk";  
+    customFieldDetails.fieldDescription = "Updated description";
+    customFieldDetails.fieldOrder = 2;
+    customFieldDetails.brandId = brandId;  
+    customFieldDetails.sharedField = true;
+    customFieldDetails.formField = formField;
+    try {
+      const updateCustomFieldResponse = await customFieldApi.editCustomField(CreatedCustomFieldId, customFieldDetails);
+      console.log("Custom field updated successfully:", updateCustomFieldResponse.body);
+      expect(updateCustomFieldResponse.body).toBeDefined();
+      expect(updateCustomFieldResponse.body.fieldName).toBe(customFieldDetails.fieldName);
+    } catch (error) {
+      console.log("Error occurred while updating the custom field:", error);
+    }
+  });
+  test('Test5:should fail to update custom field with invalid custom field ID', async () => {
+    const invalidCustomFieldId = "invalid-custom-field-id";
+    const formField = new CustomFormField();
+    formField.fieldType = CustomFormField.FieldTypeEnum.Signature;
+    formField.placeHolder = "new_placeholder";
+    formField.isRequired = true;
+    const customFieldDetails = new BrandCustomFieldDetails();
+    customFieldDetails.fieldName = "Updated Nodesdk";  
+    customFieldDetails.fieldDescription = "Updated description";
+    customFieldDetails.fieldOrder = 2;
+    customFieldDetails.brandId = brandId;
+    customFieldDetails.sharedField = true;
+    customFieldDetails.formField = formField;
+    try {
+      await customFieldApi.editCustomField(invalidCustomFieldId, customFieldDetails);
+      console.error("Expected failure but the request succeeded.");
+      throw new Error("Test failed, should have resulted in an error");
+    } catch (error) {
+      console.log("Error occurred as expected:", error);
+      expect(error).toBeDefined();
+    }
+  });
+  test('Test6:should delete a custom field successfully', async () => {
+    try {
+      const deleteCustomFieldResponse = await customFieldApi.deleteCustomField(CreatedCustomFieldId);
+      console.log("Custom field deleted successfully:", deleteCustomFieldResponse.body);
+      expect(deleteCustomFieldResponse.body).toBeDefined();
+    } catch (error) {
+      console.log("Error occurred while calling the API:", error);
+    }
+  });
+  test('Test7:should fail to delete a custom field with an invalid ID', async () => {
+    const invalidCustomFieldId = "INVALID_CUSTOMFIELD_ID";  
+    try {
+      const deleteCustomFieldResponse = await customFieldApi.deleteCustomField(invalidCustomFieldId);
+      console.log("Custom field deleted successfully:", deleteCustomFieldResponse.body);
+      throw new Error("Test failed - the custom field should not have been deleted.");
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      expect(error).toBeDefined();
+    }
+  });
+  test('Test8:should embed custom field successfully', async () => {
+    const date = new Date();
+    const linkValidTill = date;
+    try {
+      const embeddedCustomFieldResponse = await customFieldApi.embedCustomField(brandId, linkValidTill);
+      console.log("Embedded custom field response:", embeddedCustomFieldResponse);
+      expect(embeddedCustomFieldResponse).toBeDefined();
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      throw error; 
+    }
+  });
+  test('Test9:should fail to embed custom field with invalid brand ID', async () => {
+    const brandId = "INVALID_BRAND_ID";  
+    const date = new Date();
+    const linkValidTill = date;
+  
+    try {
+      const embeddedCustomFieldResponse = await customFieldApi.embedCustomField(brandId, linkValidTill);
+      throw new Error("Expected error, but API call succeeded");
+    } catch (error: any) {
+      console.error("Error occurred while calling the API:", error);
+      expect(error).toBeDefined();
+      expect(error.response).toBeDefined();
+    }
+  });
+  test('Test10:should list custom fields successfully', async () => {
+    try {
+      const customFieldListResponse = await customFieldApi.customFieldsList(brandId);
+      console.log("Custom field list:", customFieldListResponse);
+    } catch (error) {
+      console.error("Error occurred while calling the API:", error);
+      throw error;
+    }
+  });
+  test('Test11:should fail to list custom fields with invalid brandId', async () => {
+    const invalidBrandId = "invalid-brand-id";  
+    try {
+      const customFieldListResponse = await customFieldApi.customFieldsList(invalidBrandId);
+      console.error("Expected error but received a response:", customFieldListResponse);
+      throw new Error("Test failed: Expected error, but received a successful response.");
+    } catch (error:any) {
+      console.log("Expected error occurred while calling the API:", error);
+      expect(error).toBeDefined();
+      expect(error.response).toBeDefined();
+      expect(error.response.status).toBe(400);  
+    }
+  });
+});