boldsign 1.0.0-beta.1

package/tests/integration/planApiTest.spec.ts

@@ -0,0 +1,27 @@
+import { PlanApi } from '../../api/planApi';
+
+describe('PlanApiTest', () => {
+  let planApi:PlanApi;
+  beforeAll(() => {
+    const apiKey = process.env.API_KEY;
+    const hostUrl = process.env.HOST_URL;
+    if (!apiKey || !hostUrl) {
+      throw new Error("Environment variables 'API_KEY' or 'HOST_URL' are not set.");
+    }
+    planApi = new PlanApi(hostUrl);
+    planApi.setApiKey(apiKey);
+  });
+  test('should retrieve API credits count with balance greater than or equal to 0', async () => {
+    try {
+      const response = await planApi.apiCreditsCount();
+      console.log("API Credits Count:", response.body.balanceCredits);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(200);
+      expect(response.response.statusText).toBe("OK");
+      expect(response.body.balanceCredits).toBeGreaterThanOrEqual(0);
+    } catch (error) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error).toBeUndefined();
+    }
+  },20000); 
+});

package/tests/integration/senderIdentity.spec.ts

@@ -0,0 +1,193 @@
+import { SenderIdentitiesApi } from '../../api/senderIdentitiesApi';
+import { CreateSenderIdentityRequest } from '../../model';
+ 
+describe('SenderIdentityTestcase', () => {
+  let senderIdentitiesApi:SenderIdentitiesApi;
+  let createdSenderIdentityId:any
+  let emailId:any
+  const generateRandomEmail = () => {
+    const randomNum = Math.floor(1000 + Math.random() * 9000);
+    return `sdktesting${randomNum}@syncfusion.com`;
+  };
+  beforeAll(() => {
+    createdSenderIdentityId = null;
+    emailId = null;
+    const apiKey = process.env.API_KEY;
+    const baseUrl = process.env.HOST_URL;
+    if (!baseUrl || !apiKey) {
+      throw new Error("Environment variables 'HOST_URL' or 'API_KEY' are not set.");
+    }
+    senderIdentitiesApi = new SenderIdentitiesApi(baseUrl);
+    senderIdentitiesApi.setApiKey(apiKey);
+    emailId = generateRandomEmail();
+    console.log(`Generated email: ${emailId}`);
+  });
+  test('Test1: should create sender identity successfully', async () => {
+    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.body.id;
+      console.log("Created Sender Identity ID:", createdSenderIdentityId);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(201);
+      expect(response.response.statusText).toBe("Created");
+    } catch (error) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error).toBeUndefined();
+    }
+  });
+  test('Test2:should fail when invalid email ID is provided', async () => {
+    const createSenderIdentityRequest = new CreateSenderIdentityRequest();
+    createSenderIdentityRequest.name = "Luther Cooper";
+    createSenderIdentityRequest.email = "INVALID_EMAIL";  
+    createSenderIdentityRequest.redirectUrl = "https://boldsign.com";
+    try {
+      const response = await senderIdentitiesApi.createSenderIdentities(createSenderIdentityRequest);
+      console.error("Expected error due to invalid email ID, but the response was:", response);
+      throw new Error("Test failed, invalid email should not be accepted.");
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test3:should update sender identity successfully', async () => {
+    const updateSenderIdentityRequest = {
+      name: "SDKTEST",
+    };
+    try {
+      const response = await senderIdentitiesApi.updateSenderIdentities(emailId, updateSenderIdentityRequest);
+      console.log("Sender Identity updated successfully:", response);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(204);
+      expect(response.response.statusText).toBe("No Content");
+    } catch (error) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error).toBeUndefined();
+    }
+  });
+  test('Test4:should fail to update sender identity with invalid email', async () => {
+    const updateSenderIdentityRequest = {
+      name: "SDKTEST",
+    };
+    const invalidEmail = "INVALID_EMAIL";
+    try {
+      const response = await senderIdentitiesApi.updateSenderIdentities(invalidEmail, updateSenderIdentityRequest);
+      console.log("Sender Identity updated successfully:", response);
+      throw new Error("Expected error but got success.");
+    } catch (error:any) {
+      console.log("Error occurred while calling the API:", error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test5:should resend invitation sender identity successfully', async () => {
+    try {
+      const response = await senderIdentitiesApi.resendInvitationSenderIdentities(emailId);
+      console.log("Invitation resent successfully:", response);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(204);
+      expect(response.response.statusText).toBe("No Content");
+    } catch (error) {
+      console.log("Error occurred while resending invitation:", error);
+      expect(error).toBeUndefined();
+    }
+  });
+  test('Test6:should fail to resend invitation with invalid email', async () => {
+    const invalidEmail = "invalid-email-id";
+    try {
+      const response = await senderIdentitiesApi.resendInvitationSenderIdentities(invalidEmail);
+      console.log("Invitation resent successfully:", response);
+      throw new Error("Expected error but got success");
+    } catch (error:any) {
+      console.log("Error occurred while resending invitation:", error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test7:should list sender identities successfully', async () => {
+    const page = 1;
+    const pageSize = 10;
+    const search = " ";
+    const brandIds = [];
+    try {
+      const response = await senderIdentitiesApi.listSenderIdentities(page, pageSize, search, brandIds);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(200);
+      expect(response.response.statusText).toBe("OK");
+    } catch (error) {
+      console.log("Error while listing sender identities:", error);
+      expect(error).toBeUndefined();
+    }
+  });
+  test('Test8:should fail to list sender identities with invalid parameters', async () => {
+    const page = -1;
+    const pageSize = 10;
+    const search = " ";
+    const brandIds = [];
+    try {
+      await senderIdentitiesApi.listSenderIdentities(page, pageSize, search, brandIds);
+      throw new Error("Expected error but got success");
+    } catch (error:any) {
+      console.log("Error while listing sender identities:", error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test9:should throw error with invalid email', async () => {
+    const invalidEmail = "invalid-email";
+    try {
+      await senderIdentitiesApi.reRequestSenderIdentities(invalidEmail);
+      throw new Error("Expected error but got success");
+    } catch (error:any) {
+      console.log("Error occurred while re-requesting sender identity:", error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test10:should throw error with empty email', async () => {
+    const emptyEmail = " ";
+    try {
+      await senderIdentitiesApi.reRequestSenderIdentities(emptyEmail);
+      throw new Error("Expected error but got success");
+    } catch (error:any) {
+      console.log("Error occurred while re-requesting sender identity:", error);
+      expect(error.response).toBeDefined();
+      expect(error.response?.status).toBe(400);
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test11:should delete sender identity successfully', async function() {
+    try {
+        const response = await senderIdentitiesApi.deleteSenderIdentities(emailId);
+        console.log("Sender identity deleted successfully.");
+        expect(response).toBeDefined()
+        expect(response.response.status).toBe(204);
+        expect(response.response.statusText).toBe("No Content");
+    } catch (error) {
+        console.log("Error occurred while deleting sender identity:", error);
+        expect(error).toBeUndefined();
+    }
+});
+test('Test12:should fail to delete sender identity with empty email', async () => {
+    const email = "";
+    try {
+        await senderIdentitiesApi.deleteSenderIdentities(email);
+        throw new Error("Expected error but got success");
+    } catch (error:any) {
+        console.log("Error occurred while deleting sender identity:", error);
+        expect(error.response).toBeDefined();
+        expect(error.response?.status).toBe(400);
+        expect(error.response.statusText).toBe("Bad Request");
+    }
+});
+});

package/tests/integration/teamsApiTest.spec.ts

@@ -0,0 +1,167 @@
+import { TeamsApi } from '../../api/teamsApi';
+import { CreateTeamRequest, TeamListResponse, TeamUpdateRequest } from '../../model';
+ 
+describe('TeamsTestcase', () => {
+let teamsApi:TeamsApi;
+let createdTeamId:any
+let teamName:any
+const randomNumbers = () => {
+const randomNum = Math.floor(100 + Math.random() * 900);
+return String(randomNum);
+};
+beforeAll(() => {
+    createdTeamId = null;
+    teamName = null;
+    const apiKey = process.env.API_KEY;
+    const hostUrl = process.env.HOST_URL;
+    if (!apiKey || !hostUrl) {
+        throw new Error("Environment variables 'API_KEY' or 'HOST_URL' are not set.");
+    }
+    teamsApi = new TeamsApi(hostUrl);
+    teamsApi.setApiKey(apiKey);
+    teamName = `sdktestingteam${randomNumbers()}`;
+});
+ 
+test('Test1: should create team successfully', async () => {
+    const createTeamRequest = new CreateTeamRequest();
+    createTeamRequest.teamName = teamName;
+    try {
+        const createTeamResponse = await teamsApi.createTeam(createTeamRequest);
+        console.log('Team created successfully:', createTeamResponse);
+        const createdTeam = createTeamResponse?.body;
+        if (createdTeam && createdTeam.teamId) {
+            createdTeamId = String(createdTeam.teamId);
+            console.log('Created Team ID:', createdTeamId);
+        } else {
+            console.error('Team ID not found in response.');
+            throw new Error('Team creation failed.');
+        }
+        expect(createTeamResponse.body.teamId).toBeDefined;
+        expect(createTeamResponse.response.status).toBe(200);
+        expect(createTeamResponse.response.statusText).toBe("OK");
+        console.log('Created Team ID:', createdTeamId);
+    } catch (error) {
+        console.error('Error occurred while creating team:', error);
+        expect(error).toBeUndefined();
+    }
+});
+test('Test2: should return error when team name already exists', async () => {
+    const createTeamRequest = new CreateTeamRequest();
+    createTeamRequest.teamName = teamName;
+    try {
+        const response = await teamsApi.createTeam(createTeamRequest);
+        console.log('Team created successfully:', response);
+    } catch (error: any) {
+        console.error('Error occurred while creating team:', error);
+        expect(error).toBeDefined();
+        expect(error.response.status).toBe(400);
+        expect(error.response.statusText).toBe('Bad Request');
+    }
+});
+test('Test3: should successfully retrieve team list with valid parameters', async () => {
+    const page = 1;
+    const pageSize = 100;
+    try {
+        const teamListResponse = await teamsApi.listTeams(page, pageSize);
+        expect(teamListResponse.body.results).toBeDefined;
+        expect(teamListResponse.response.status).toBe(200);
+        expect(teamListResponse.response.statusText).toBe("OK");
+        const teamsList = teamListResponse.body?.results;
+        if (Array.isArray(teamsList)) {
+            for (let team of teamsList) {
+                if (team.teamName === teamName) {
+                    createdTeamId = team.teamId;
+                    console.log("Created Team ID:", createdTeamId);
+                    break;
+                }
+            }
+        } else {
+            console.error("teamsList is not an array or is null/undefined.");
+            throw new Error("teamsList is invalid.");
+        }
+        expect(createdTeamId !=null);
+    } catch (error: any) {
+        console.error("Error occurred while retrieving team list:", error);
+        expect(error).toBeUndefined();
+    }
+});
+test('Test4:should fail to retrieve team list when invalid parameters are passed', async () => {
+    const page = -1;
+    const pageSize = -10;
+    try {
+        const teamListResponse = await teamsApi.listTeams(page, pageSize);
+        console.error("Unexpected success response:", teamListResponse.body);
+        throw new Error("Expected error, but API call succeeded");
+    }
+    catch (error:any)
+    {
+        console.log("Expected error occurred:", error);
+        expect(error).toBeDefined();
+        expect(error.response.status).toBe(400);
+        expect(error.response.statusText).toBe('Bad Request');
+    }
+});
+test('Test5:should return true when valid team update request is passed', async () => {
+    const teamUpdateRequest = new TeamUpdateRequest();
+    teamUpdateRequest.teamId = createdTeamId;
+    teamUpdateRequest.teamName = "Update"+teamName;
+    console.log("Teamid before update:",  createdTeamId);
+    try
+    {
+        const records = await teamsApi.updateTeam(teamUpdateRequest);
+        console.log("Team updated successfully:", records);
+        expect(records.response.status).toBe(200);
+        expect(records.response.statusText).toBe("OK");
+    }
+    catch (error)
+    {
+        console.error("Error during team update:", error);
+        expect(error).toBeUndefined();
+    }
+});
+test('Test6:should throw error when invalid team ID is provided', async () => {
+    const teamUpdateRequest = {
+        teamId: "wrongTeamId",
+        teamName: teamName,
+    };
+    try
+    {
+        await teamsApi.updateTeam(teamUpdateRequest);
+    }
+    catch (error:any)
+    {
+        expect(error).toBeDefined();
+        expect(error.response.status).toBe(400);
+        expect(error.response.statusText).toBe('Bad Request');
+    }
+});
+test('Test7:should return true when valid team get request is passed', async () => {
+    try
+    {
+        const records = await teamsApi.getTeam(createdTeamId);
+        console.log(records);
+        expect(records.body.teamName != null);
+        expect(records.response.status).toBe(200);
+        expect(records.response.statusText).toBe("OK");
+    }
+    catch (error)
+    {
+        console.error("Error fetching team:", error);
+        expect(error).toBeUndefined();
+    }
+});
+test('Test8:should throw error when invalid team ID is provided', async () => {
+    const invalidTeamId = "INVALID_TEAMID";
+    try
+    {
+        await teamsApi.getTeam(invalidTeamId);
+    }
+    catch (error:any)
+    {
+        console.log("Expected exception occurred: " + error.message);
+        expect(error).toBeDefined();
+        expect(error.response.status).toBe(400);
+        expect(error.response.statusText).toBe('Bad Request');
+    }
+});
+});

package/tests/integration/usersApiTest.spec.ts

@@ -0,0 +1,198 @@
+import { UserApi } from '../../api/userApi';
+import { CreateUser } from '../../model';
+
+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 = process.env.API_KEY;
+    const baseUrl = process.env.HOST_URL;
+    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();
+        expect(response.response.status).toBe(200);
+        expect(response.response.statusText).toBe("OK");
+      } catch (error) {
+        console.error("Error occurred while calling the API:", error);
+        expect(error).toBeUndefined();
+      }
+  });
+  test('Test2: should retrieve list of users successfully', async () => {
+    const page = 1;
+    const pageSize = 20;
+    const search = '';
+    try {
+      const response = await usersApi.listUsers(page, pageSize, search);
+      console.log('Users list retrieved successfully:', response);
+      const usersList = response.body?.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();
+      expect(response.response.status).toBe(200);
+      expect(response.response.statusText).toBe("OK");
+      console.log("Created User ID:", createdUserId);
+    } catch (error) {
+      console.error('Error occurred while retrieving users:', error);
+      expect(error).toBeUndefined();
+    }
+  });
+  test('Test3: should fail to retrieve list of users with invalid 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);
+      expect(error.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test4:should return error 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.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test5:should return error 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.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request"); 
+    }
+  });
+  test('Test6:should return error 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.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test7:should retrieve user successfully', async () => {
+    try {
+      const response = await usersApi.getUser(createdUserId);
+      console.log('User retrieved successfully:', response);
+      expect(response).toBeDefined();
+      expect(response.response.status).toBe(200);
+      expect(response.response.statusText).toBe("OK");
+    } catch (error) {
+      console.error("Error occurred while retrieving the user:", error);
+    }  
+  });
+  test('Test8:should return error 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.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test9: should resend invitation successfully', async () => {
+    try {
+      const response = await usersApi.resendInvitation(createdUserId);
+      expect(response).toBeDefined(); 
+      expect(response.response.status).toBe(200);  
+      expect(response.response.statusText).toBe("OK"); 
+      console.log('Invitation resent successfully!');
+    } catch (error: any) {
+      console.error('Error occurred while resending the invitation:', error);
+      throw new Error('Invitation resend failed');
+    }
+  });
+  test('Test10: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);
+      expect(error).toBeDefined();
+      expect(error.response).toBeDefined(); 
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+  test('Test11: should cancel invitation successfully', async () => {
+    try {
+      const response = await usersApi.cancelInvitation(createdUserId);
+      expect(response).toBeDefined(); 
+      expect(response.response.status).toBe(200); 
+      expect(response.response.statusText).toBe("OK"); 
+      console.log('Invitation canceled successfully!');
+    } catch (error: any) {
+      console.error('Error occurred while canceling the invitation:', error);
+      expect(error).toBeUndefined();
+    }
+  });
+  test('Test12: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);
+      expect(error).toBeDefined();
+      expect(error.response?.status).toBe(400); 
+      expect(error.response.statusText).toBe("Bad Request");
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "noImplicitAny": false,
+        "target": "ES6",
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
+        "strict": true,
+        "moduleResolution": "node",
+        "removeComments": true,
+        "sourceMap": true,
+        "noLib": false,
+        "declaration": true,
+        "lib": ["dom", "es6", "es5", "dom.iterable", "scripthost"],
+        "outDir": "dist",
+        "typeRoots": [
+            "node_modules/@types"
+        ]
+    },
+    "exclude": [
+        "dist",
+        "node_modules"
+    ]
+}