boldsign/tests/integration/CustomFieldApiTest.spec.ts

NodeJS client for boldsign

import { CustomFieldApi } from '../../api/customFieldApi';
import { BrandingApi } from '../../api/brandingApi';
import {BrandCustomFieldDetails, CustomFormField } from '../../model';
import config from '../config';
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 apiKey = config.apiKey;
    const baseUrl = config.baseUrl;
    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/documents/logo.jpg");
      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.brandId);
        brandId = createBrandApiResponse.brandId;
        expect(brandId).toBeDefined();
        expect(brandId).toBeGreaterThan(0);
      } catch (error:any) {
        console.log("Error occurred while creating the brand:", error.message);
      }
    },20000);
  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);
      CreatedCustomFieldId = createCustomFieldResponse.customFieldId;
      console.log("Created Custom Field ID:", CreatedCustomFieldId);
      expect(createCustomFieldResponse).toBeDefined();
      expect(CreatedCustomFieldId).toBeDefined();
      expect(CreatedCustomFieldId).toBeGreaterThan(0);
    } catch (error:any) {
      console.log("Error occurred while calling the API:", error.message);
    }
  },20000);
  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).toHaveProperty('id');
      expect(createCustomFieldResponse.id).not.toBeNull();
      expect(createCustomFieldResponse.fieldName).toBe(customFieldDetails.fieldName);
    } catch (error:any) {
      console.error("Error occurred while calling the API:", error.message);
      expect(error.message).toBeDefined();
    }
  }, 20000);
  test('Test5: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);
      expect(updateCustomFieldResponse).toBeDefined();
      expect(updateCustomFieldResponse.fieldName).toBe(customFieldDetails.fieldName);
    } catch (error:any) {
      console.log("Error occurred while updating the custom field:", error.message);
    }
  },20000);
  test('Test6: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:any) {
      console.log("Error occurred as expected:", error.message);
      expect(error.message).toBeDefined();
    }
  },20000);
  test('Test7: should fail to update custom field with invalid brand ID', async () => {
    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 = "invalid-brand-id";
    customFieldDetails.sharedField = true;
    customFieldDetails.formField = formField;
    try {
      await customFieldApi.editCustomField(CreatedCustomFieldId, customFieldDetails);
      console.error("Expected failure but the request succeeded.");
      throw new Error("Test failed, should have resulted in an error");
    } catch (error: any) {
      console.log("Error occurred as expected:", error);
      expect(error.response).toBeDefined();
      expect(error.response?.status).toBe(400);
      expect(error.response.statusText).toBe("Bad Request");
    }
  },20000);
  test('Test8:should delete a custom field successfully', async () => {
    try {
      const deleteCustomFieldResponse = await customFieldApi.deleteCustomField(CreatedCustomFieldId);
      console.log("Custom field deleted successfully:", deleteCustomFieldResponse);
      expect(deleteCustomFieldResponse).toBeDefined();
    } catch (error:any) {
      console.log("Error occurred while calling the API:", error.message);
    }
  },20000);
  test('Test9: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);
      throw new Error("Test failed - the custom field should not have been deleted.");
    } catch (error:any) {
      console.error("Error occurred while calling the API:", error.message);
      expect(error.message).toBeDefined();
    }
  },2000);
  test('Test10:should embed custom field successfully', async () => {
    const date = new Date();
    const linkValidTill = new Date(date.setDate(date.getDate() + 20));
    try {
      const embeddedCustomFieldResponse = await customFieldApi.embedCustomField(brandId, linkValidTill);
      console.log("Embedded custom field response:", embeddedCustomFieldResponse);
      expect(embeddedCustomFieldResponse).toBeDefined();
    } catch (error:any) {
      console.error("Error occurred while calling the API:", error.message);
      throw error;
    }
  },20000);
  test('Test11:should fail to embed custom field with invalid brand ID', async () => {
    const brandId = "INVALID_BRAND_ID";
    const date = new Date();
    const linkValidTill = new Date(date.setDate(date.getDate() + 20));
  
    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.message);
      expect(error.message).toBeDefined();
      
    }
  },20000);
  test('Test12:should list custom fields successfully', async () => {
    try {
      const customFieldListResponse = await customFieldApi.customFieldsList(brandId);
      console.log("Custom field list:", customFieldListResponse);
    } catch (error:any) {
      console.error("Error occurred while calling the API:", error.message);
      throw error;
    }
  },20000);
  test('Test13: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.message);
      expect(error.message).toBeDefined();
    }
  }, 20000);
});