diff --git a/test/mock-api/users/common_test_constants.js b/test/mock-api/users/common_test_constants.js
index 56375d6..1224a6c 100644
--- a/test/mock-api/users/common_test_constants.js
+++ b/test/mock-api/users/common_test_constants.js
@@ -1,11 +1,78 @@
+// Common User IDs
 const TEST_USER_ID = 12345678;
 const TEST_PLAN_ID = 1234567890123456;
+const TEST_ACCOUNT_ID = 9876543210987654;
+
+// Common Alternate Email ID
+const TEST_ALTERNATE_EMAIL_ID = 9876543210987654;
+
+// Common User Contact Information
+const TEST_MOBILE_PHONE = '+1234567890';
+const TEST_EMAIL = 'test.user@smartsheet.com';
+const TEST_ALTERNATE_EMAIL = 'alternate.email@smartsheet.com';
+
+// Common User Names
+const TEST_FIRST_NAME = 'Test';
+const TEST_LAST_NAME = 'User';
+const TEST_NAME = 'Test User';
+
+// Common User Timestamps
+const TEST_CUSTOM_WELCOME_SCREEN_VIEWED = '2020-08-25T12:15:47Z';
+const TEST_LAST_LOGIN = '2020-10-04T18:32:47Z';
+const TEST_PROVISIONAL_EXPIRATION_DATE = '2026-12-13T12:17:52.525696Z';
+const TEST_SEAT_TYPE_LAST_CHANGED_AT = '2025-01-01T00:00:00.123456789Z';
+
+// Common Pagination Properties
+const TEST_PAGE_NUMBER = 1;
+const TEST_PAGE_SIZE = 100;
+const TEST_TOTAL_PAGES = 1;
+const TEST_TOTAL_COUNT = 1;
+
+// Common User Properties
+const TEST_SHEET_COUNT = -1;
+
+// Common Profile Image Properties
+const TEST_PROFILE_IMAGE_ID = 'u!1!nAtdn5RJB_o!k6_e_3h2R3w!wmYXPek-yVD';
+const TEST_PROFILE_IMAGE_HEIGHT = 1050;
+const TEST_PROFILE_IMAGE_WIDTH = 1050;
+
+// Common Success Response Values
 const TEST_SUCCESS_MESSAGE = 'SUCCESS';
 const TEST_SUCCESS_RESULT_CODE = 0;
 
+// Common Error Status Codes
+const ERROR_500_STATUS_CODE = 500;
+const ERROR_500_MESSAGE = 'Internal Server Error';
+const ERROR_400_STATUS_CODE = 400;
+const ERROR_400_MESSAGE = 'Malformed Request';
+
 module.exports = {
   TEST_USER_ID,
   TEST_PLAN_ID,
+  TEST_ACCOUNT_ID,
+  TEST_ALTERNATE_EMAIL_ID,
+  TEST_MOBILE_PHONE,
+  TEST_EMAIL,
+  TEST_ALTERNATE_EMAIL,
+  TEST_FIRST_NAME,
+  TEST_LAST_NAME,
+  TEST_NAME,
+  TEST_CUSTOM_WELCOME_SCREEN_VIEWED,
+  TEST_LAST_LOGIN,
+  TEST_PROVISIONAL_EXPIRATION_DATE,
+  TEST_SEAT_TYPE_LAST_CHANGED_AT,
+  TEST_PAGE_NUMBER,
+  TEST_PAGE_SIZE,
+  TEST_TOTAL_PAGES,
+  TEST_TOTAL_COUNT,
+  TEST_SHEET_COUNT,
+  TEST_PROFILE_IMAGE_ID,
+  TEST_PROFILE_IMAGE_HEIGHT,
+  TEST_PROFILE_IMAGE_WIDTH,
   TEST_SUCCESS_MESSAGE,
-  TEST_SUCCESS_RESULT_CODE
+  TEST_SUCCESS_RESULT_CODE,
+  ERROR_500_STATUS_CODE,
+  ERROR_500_MESSAGE,
+  ERROR_400_STATUS_CODE,
+  ERROR_400_MESSAGE
 };
diff --git a/test/mock-api/users/test_add_alternate_email.js b/test/mock-api/users/test_add_alternate_email.js
new file mode 100644
index 0000000..7d03a2c
--- /dev/null
+++ b/test/mock-api/users/test_add_alternate_email.js
@@ -0,0 +1,100 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - addAlternateEmail endpoint tests', function () {
+    let client = createClient();
+    const TEST_EMAIL = 'alternate.email@smartsheet.com';
+    const TEST_CONFIRMED = false;
+    const TEST_BODY = [{ email: TEST_EMAIL }];
+
+    it('addAlternateEmail generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: TEST_BODY,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/add-alternate-email/all-response-body-properties'
+            }
+        };
+        await client.users.addAlternateEmail(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/alternateemails`));
+    });
+
+    it('addAlternateEmail all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: TEST_BODY,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/add-alternate-email/all-response-body-properties'
+            }
+        };
+        const response = await client.users.addAlternateEmail(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.ok(Array.isArray(response.data));
+        assert.strictEqual(response.data.length, 1);
+        assert.strictEqual(response.data[0].id, TEST_ALTERNATE_EMAIL_ID);
+        assert.strictEqual(response.data[0].confirmed, TEST_CONFIRMED);
+        assert.strictEqual(response.data[0].email, TEST_EMAIL);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.deepStrictEqual(body, TEST_BODY);
+    });
+
+    it('addAlternateEmail error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: TEST_BODY,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.addAlternateEmail(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('addAlternateEmail error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: TEST_BODY,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.addAlternateEmail(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_add_profile_image.js b/test/mock-api/users/test_add_profile_image.js
new file mode 100644
index 0000000..3205239
--- /dev/null
+++ b/test/mock-api/users/test_add_profile_image.js
@@ -0,0 +1,126 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_EMAIL,
+    TEST_FIRST_NAME,
+    TEST_LAST_NAME,
+    TEST_NAME,
+    TEST_PROFILE_IMAGE_ID,
+    TEST_PROFILE_IMAGE_HEIGHT,
+    TEST_PROFILE_IMAGE_WIDTH,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - addProfileImage endpoint tests', function () {
+    let client = createClient();
+    const imageId = TEST_PROFILE_IMAGE_ID;
+    const height = TEST_PROFILE_IMAGE_HEIGHT;
+    const width = TEST_PROFILE_IMAGE_WIDTH;
+    const email = TEST_EMAIL;
+    const name = TEST_NAME;
+    const firstName = TEST_FIRST_NAME;
+    const lastName = TEST_LAST_NAME;
+
+    it('addProfileImage generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const mockImageBuffer = Buffer.from('fake-image-data');
+        const options = {
+            userId: TEST_USER_ID,
+            body: {
+                file: mockImageBuffer
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/add-profile-image/all-response-body-properties'
+            }
+        };
+        await client.users.addProfileImage(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/profileimage`));
+    });
+
+    it('addProfileImage all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const mockImageBuffer = Buffer.from('fake-image-data');
+        const options = {
+            userId: TEST_USER_ID,
+            body: {
+                file: mockImageBuffer
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/add-profile-image/all-response-body-properties'
+            }
+        };
+        const response = await client.users.addProfileImage(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.ok(response.data);
+        assert.strictEqual(response.data.length, 1);
+        assert.strictEqual(response.data[0].id, TEST_USER_ID);
+        assert.strictEqual(response.data[0].email, email);
+        assert.strictEqual(response.data[0].name, name);
+        assert.strictEqual(response.data[0].firstName, firstName);
+        assert.strictEqual(response.data[0].lastName, lastName);
+        assert.ok(response.data[0].profileImage);
+        assert.strictEqual(response.data[0].profileImage.imageId, imageId);
+        assert.strictEqual(response.data[0].profileImage.height, height);
+        assert.strictEqual(response.data[0].profileImage.width, width);
+        assert.strictEqual(matchedRequest.body.includes('fake-image-data'), true);
+    });
+
+    it('addProfileImage error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const mockImageBuffer = Buffer.from('fake-image-data');
+        const options = {
+            userId: TEST_USER_ID,
+            body: {
+                file: mockImageBuffer
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.addProfileImage(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('addProfileImage error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const mockImageBuffer = Buffer.from('fake-image-data');
+        const options = {
+            userId: TEST_USER_ID,
+            body: {
+                file: mockImageBuffer
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.addProfileImage(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_add_user.js b/test/mock-api/users/test_add_user.js
new file mode 100644
index 0000000..f543c12
--- /dev/null
+++ b/test/mock-api/users/test_add_user.js
@@ -0,0 +1,223 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_EMAIL,
+    TEST_FIRST_NAME,
+    TEST_LAST_NAME,
+    TEST_NAME,
+    TEST_CUSTOM_WELCOME_SCREEN_VIEWED,
+    TEST_LAST_LOGIN,
+    TEST_PROVISIONAL_EXPIRATION_DATE,
+    TEST_SEAT_TYPE_LAST_CHANGED_AT,
+    TEST_SHEET_COUNT,
+    TEST_PROFILE_IMAGE_ID,
+    TEST_PROFILE_IMAGE_HEIGHT,
+    TEST_PROFILE_IMAGE_WIDTH,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE,
+    TEST_USER_ID
+} = require('./common_test_constants.js');
+
+describe('Users - addUser endpoint tests', function () {
+    let client = createClient();
+    const newUserId = TEST_USER_ID;
+    const email = TEST_EMAIL;
+    const firstName = TEST_FIRST_NAME;
+    const lastName = TEST_LAST_NAME;
+    const name = TEST_NAME;
+    const admin = false;
+    const licensedSheetCreator = true;
+    const groupAdmin = false;
+    const resourceViewer = false;
+    const status = 'ACTIVE';
+    const customWelcomeScreenViewed = TEST_CUSTOM_WELCOME_SCREEN_VIEWED;
+    const lastLogin = TEST_LAST_LOGIN;
+    const isInternal = true;
+    const profileImageId = TEST_PROFILE_IMAGE_ID;
+    const profileImageHeight = TEST_PROFILE_IMAGE_HEIGHT;
+    const profileImageWidth = TEST_PROFILE_IMAGE_WIDTH;
+    const provisionalExpirationDate = TEST_PROVISIONAL_EXPIRATION_DATE;
+    const seatType = 'MEMBER';
+    const seatTypeLastChangedAt = TEST_SEAT_TYPE_LAST_CHANGED_AT;
+    const sheetCount = TEST_SHEET_COUNT;
+
+    const testUserBody = {
+        email: email,
+        firstName: firstName,
+        lastName: lastName,
+        admin: admin,
+        licensedSheetCreator: licensedSheetCreator,
+        groupAdmin: groupAdmin,
+        resourceViewer: resourceViewer,
+        status: status
+    };
+
+    it('addUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            body: testUserBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/add-user/all-response-body-properties'
+            }
+        };
+        await client.users.addUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes('/2.0/users'));
+    });
+    it('addUserAndSendEmail generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            body: testUserBody,
+            queryParameters: {
+                sendEmail: true
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/add-user/all-response-body-properties'
+            }
+        };
+        await client.users.addUserAndSendEmail(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes('/2.0/users'));
+        const queryParams = matchedRequest.queryParams;
+        const sendEmailActual = queryParams.sendEmail.values[0];
+        assert.strictEqual(sendEmailActual, 'true');
+    });
+
+
+    it('addUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            body: testUserBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/add-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.addUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.strictEqual(response.result.id, newUserId);
+        assert.strictEqual(response.result.admin, admin);
+        assert.strictEqual(response.result.customWelcomeScreenViewed, customWelcomeScreenViewed);
+        assert.strictEqual(response.result.email, email);
+        assert.strictEqual(response.result.firstName, firstName);
+        assert.strictEqual(response.result.groupAdmin, groupAdmin);
+        assert.strictEqual(response.result.isInternal, isInternal);
+        assert.strictEqual(response.result.lastLogin, lastLogin);
+        assert.strictEqual(response.result.lastName, lastName);
+        assert.strictEqual(response.result.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(response.result.name, name);
+        assert.strictEqual(response.result.profileImage.imageId, profileImageId);
+        assert.strictEqual(response.result.profileImage.height, profileImageHeight);
+        assert.strictEqual(response.result.profileImage.width, profileImageWidth);
+        assert.strictEqual(response.result.provisionalExpirationDate, provisionalExpirationDate);
+        assert.strictEqual(response.result.resourceViewer, resourceViewer);
+        assert.strictEqual(response.result.seatType, seatType);
+        assert.strictEqual(response.result.seatTypeLastChangedAt, seatTypeLastChangedAt);
+        assert.strictEqual(response.result.sheetCount, sheetCount);
+        assert.strictEqual(response.result.status, status);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.strictEqual(body.email, email);
+        assert.strictEqual(body.firstName, firstName);
+        assert.strictEqual(body.lastName, lastName);
+        assert.strictEqual(body.admin, admin);
+        assert.strictEqual(body.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(body.groupAdmin, groupAdmin);
+        assert.strictEqual(body.resourceViewer, resourceViewer);
+        assert.strictEqual(body.status, status);
+    });
+
+    it('addUser required response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            body: testUserBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/add-user/required-response-body-properties'
+            }
+        };
+        const response = await client.users.addUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.strictEqual(response.result.id, newUserId);
+        assert.strictEqual(response.result.admin, undefined);
+        assert.strictEqual(response.result.customWelcomeScreenViewed, undefined);
+        assert.strictEqual(response.result.email, email);
+        assert.strictEqual(response.result.firstName, firstName);
+        assert.strictEqual(response.result.groupAdmin, undefined);
+        assert.strictEqual(response.result.isInternal, undefined);
+        assert.strictEqual(response.result.lastLogin, undefined);
+        assert.strictEqual(response.result.lastName, lastName);
+        assert.strictEqual(response.result.licensedSheetCreator, undefined);
+        assert.strictEqual(response.result.name, name);
+        assert.strictEqual(response.result.profileImage, undefined);
+        assert.strictEqual(response.result.provisionalExpirationDate, undefined);
+        assert.strictEqual(response.result.resourceViewer, undefined);
+        assert.strictEqual(response.result.seatType, undefined);
+        assert.strictEqual(response.result.seatTypeLastChangedAt, undefined);
+        assert.strictEqual(response.result.sheetCount, undefined);
+        assert.strictEqual(response.result.status, status);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.strictEqual(body.email, email);
+        assert.strictEqual(body.firstName, firstName);
+        assert.strictEqual(body.lastName, lastName);
+        assert.strictEqual(body.admin, admin);
+        assert.strictEqual(body.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(body.groupAdmin, groupAdmin);
+        assert.strictEqual(body.resourceViewer, resourceViewer);
+        assert.strictEqual(body.status, status);
+    });
+
+    it('addUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            body: testUserBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.addUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('addUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            body: testUserBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.addUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_deactivate_reactivate_user.js b/test/mock-api/users/test_deactivate_reactivate_user.js
new file mode 100644
index 0000000..1cbc5ea
--- /dev/null
+++ b/test/mock-api/users/test_deactivate_reactivate_user.js
@@ -0,0 +1,148 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - deactivateUser & reactivateUser endpoint tests', function () {
+    let client = createClient();
+
+    it('deactivateUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/deactivate-user/all-response-body-properties'
+            }
+        };
+        await client.users.deactivateUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/deactivate`));
+    });
+
+    it('deactivateUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/deactivate-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.deactivateUser(options);
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+    });
+
+    it('deactivateUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.deactivateUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('deactivateUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.deactivateUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+
+    it('reactivateUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/reactivate-user/all-response-body-properties'
+            }
+        };
+        await client.users.reactivateUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/reactivate`));
+    });
+
+    it('reactivateUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/reactivate-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.reactivateUser(options);
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+    });
+
+    it('reactivateUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.reactivateUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('reactivateUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.reactivateUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_delete_alternate_email.js b/test/mock-api/users/test_delete_alternate_email.js
new file mode 100644
index 0000000..69ce9b8
--- /dev/null
+++ b/test/mock-api/users/test_delete_alternate_email.js
@@ -0,0 +1,87 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - deleteAlternateEmail endpoint tests', function () {
+    let client = createClient();
+
+    it('deleteAlternateEmail generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/delete-alternate-email/all-response-body-properties'
+            }
+        };
+        await client.users.deleteAlternateEmail(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/alternateemails/${TEST_ALTERNATE_EMAIL_ID}`));
+    });
+
+    it('deleteAlternateEmail all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/delete-alternate-email/all-response-body-properties'
+            }
+        };
+        const response = await client.users.deleteAlternateEmail(options);
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+    });
+
+    it('deleteAlternateEmail error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.deleteAlternateEmail(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('deleteAlternateEmail error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.deleteAlternateEmail(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_get_alternate_email.js b/test/mock-api/users/test_get_alternate_email.js
new file mode 100644
index 0000000..03e0d40
--- /dev/null
+++ b/test/mock-api/users/test_get_alternate_email.js
@@ -0,0 +1,88 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - getAlternateEmail endpoint tests', function () {
+    let client = createClient();
+    const TEST_EMAIL = 'alternate.email@smartsheet.com';
+    const TEST_CONFIRMED = true;
+
+    it('getAlternateEmail generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/get-alternate-email/all-response-body-properties'
+            }
+        };
+        await client.users.getAlternateEmail(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/alternateemails/${TEST_ALTERNATE_EMAIL_ID}`));
+    });
+
+    it('getAlternateEmail all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/get-alternate-email/all-response-body-properties'
+            }
+        };
+        const response = await client.users.getAlternateEmail(options);
+        assert.ok(response);
+        assert.strictEqual(response.id, TEST_ALTERNATE_EMAIL_ID);
+        assert.strictEqual(response.confirmed, TEST_CONFIRMED);
+        assert.strictEqual(response.email, TEST_EMAIL);
+    });
+
+    it('getAlternateEmail error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.getAlternateEmail(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('getAlternateEmail error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.getAlternateEmail(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_get_current_user.js b/test/mock-api/users/test_get_current_user.js
new file mode 100644
index 0000000..cb9e6f0
--- /dev/null
+++ b/test/mock-api/users/test_get_current_user.js
@@ -0,0 +1,202 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ACCOUNT_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    TEST_MOBILE_PHONE,
+    TEST_EMAIL,
+    TEST_ALTERNATE_EMAIL,
+    TEST_FIRST_NAME,
+    TEST_LAST_NAME,
+    TEST_CUSTOM_WELCOME_SCREEN_VIEWED,
+    TEST_LAST_LOGIN,
+    TEST_SHEET_COUNT,
+    TEST_PROFILE_IMAGE_ID,
+    TEST_PROFILE_IMAGE_HEIGHT,
+    TEST_PROFILE_IMAGE_WIDTH,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - getCurrentUser endpoint tests', function () {
+    let client = createClient();
+    const userId = TEST_USER_ID;
+    const accountId = TEST_ACCOUNT_ID;
+    const accountName = 'Test Account';
+    const admin = true;
+    const alternateEmailId = TEST_ALTERNATE_EMAIL_ID;
+    const alternateEmailConfirmed = true;
+    const alternateEmail = TEST_ALTERNATE_EMAIL;
+    const company = 'Test Company';
+    const customWelcomeScreenViewed = TEST_CUSTOM_WELCOME_SCREEN_VIEWED;
+    const department = 'Engineering';
+    const email = TEST_EMAIL;
+    const firstName = TEST_FIRST_NAME;
+    const groupAdmin = true;
+    const jiraAdmin = false;
+    const lastLogin = TEST_LAST_LOGIN;
+    const lastName = TEST_LAST_NAME;
+    const licensedSheetCreator = true;
+    const locale = 'en_US';
+    const mobilePhone = TEST_MOBILE_PHONE;
+    const profileImageId = TEST_PROFILE_IMAGE_ID;
+    const profileImageHeight = TEST_PROFILE_IMAGE_HEIGHT;
+    const profileImageWidth = TEST_PROFILE_IMAGE_WIDTH;
+    const resourceViewer = true;
+    const role = 'System Admin';
+    const salesforceAdmin = false;
+    const salesforceUser = false;
+    const sheetCount = TEST_SHEET_COUNT;
+    const timeZone = 'US/Pacific';
+    const title = 'Senior Engineer';
+    const workPhone = TEST_MOBILE_PHONE;
+    const groupId = 2222222222222222;
+    const groupName = 'Engineering Team';
+    const groupDescription = 'Engineering department group';
+    const groupOwner = 'owner@smartsheet.com';
+    const groupOwnerId = 3333333333333333;
+    const groupCreatedAt = '2020-01-15T10:30:00Z';
+    const groupModifiedAt = '2020-06-20T14:45:00Z';
+
+    it('getCurrentUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/get-current-user/all-response-body-properties'
+            }
+        };
+        await client.users.getCurrentUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes('/2.0/users/me'));
+    });
+
+    it('getCurrentUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/get-current-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.getCurrentUser(options);
+        assert.ok(response);
+        assert.strictEqual(response.id, userId);
+        assert.strictEqual(response.account.id, accountId);
+        assert.strictEqual(response.account.name, accountName);
+        assert.strictEqual(response.admin, admin);
+        assert.strictEqual(response.alternateEmails.length, 1);
+        assert.strictEqual(response.alternateEmails[0].id, alternateEmailId);
+        assert.strictEqual(response.alternateEmails[0].confirmed, alternateEmailConfirmed);
+        assert.strictEqual(response.alternateEmails[0].email, alternateEmail);
+        assert.strictEqual(response.company, company);
+        assert.strictEqual(response.customWelcomeScreenViewed, customWelcomeScreenViewed);
+        assert.strictEqual(response.department, department);
+        assert.strictEqual(response.email, email);
+        assert.strictEqual(response.firstName, firstName);
+        assert.strictEqual(response.groupAdmin, groupAdmin);
+        assert.strictEqual(response.jiraAdmin, jiraAdmin);
+        assert.strictEqual(response.lastLogin, lastLogin);
+        assert.strictEqual(response.lastName, lastName);
+        assert.strictEqual(response.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(response.locale, locale);
+        assert.strictEqual(response.mobilePhone, mobilePhone);
+        assert.strictEqual(response.profileImage.imageId, profileImageId);
+        assert.strictEqual(response.profileImage.height, profileImageHeight);
+        assert.strictEqual(response.profileImage.width, profileImageWidth);
+        assert.strictEqual(response.resourceViewer, resourceViewer);
+        assert.strictEqual(response.role, role);
+        assert.strictEqual(response.salesforceAdmin, salesforceAdmin);
+        assert.strictEqual(response.salesforceUser, salesforceUser);
+        assert.strictEqual(response.sheetCount, sheetCount);
+        assert.strictEqual(response.timeZone, timeZone);
+        assert.strictEqual(response.title, title);
+        assert.strictEqual(response.workPhone, workPhone);
+        assert.strictEqual(response.data.length, 1);
+        assert.strictEqual(response.data[0].id, groupId);
+        assert.strictEqual(response.data[0].name, groupName);
+        assert.strictEqual(response.data[0].description, groupDescription);
+        assert.strictEqual(response.data[0].owner, groupOwner);
+        assert.strictEqual(response.data[0].ownerId, groupOwnerId);
+        assert.strictEqual(response.data[0].createdAt, groupCreatedAt);
+        assert.strictEqual(response.data[0].modifiedAt, groupModifiedAt);
+    });
+
+    it('getCurrentUser required response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/get-current-user/required-response-body-properties'
+            }
+        };
+        const response = await client.users.getCurrentUser(options);
+        assert.ok(response);
+        assert.strictEqual(response.id, userId);
+        assert.strictEqual(response.account.id, accountId);
+        assert.strictEqual(response.account.name, accountName);
+        assert.strictEqual(response.admin, admin);
+        assert.strictEqual(response.alternateEmails, undefined);
+        assert.strictEqual(response.company, company);
+        assert.strictEqual(response.customWelcomeScreenViewed, undefined);
+        assert.strictEqual(response.department, department);
+        assert.strictEqual(response.email, email);
+        assert.strictEqual(response.firstName, firstName);
+        assert.strictEqual(response.groupAdmin, groupAdmin);
+        assert.strictEqual(response.jiraAdmin, jiraAdmin);
+        assert.strictEqual(response.lastLogin, undefined);
+        assert.strictEqual(response.lastName, lastName);
+        assert.strictEqual(response.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(response.locale, locale);
+        assert.strictEqual(response.mobilePhone, mobilePhone);
+        assert.strictEqual(response.profileImage, undefined);
+        assert.strictEqual(response.resourceViewer, resourceViewer);
+        assert.strictEqual(response.role, role);
+        assert.strictEqual(response.salesforceAdmin, salesforceAdmin);
+        assert.strictEqual(response.salesforceUser, salesforceUser);
+        assert.strictEqual(response.sheetCount, sheetCount);
+        assert.strictEqual(response.timeZone, timeZone);
+        assert.strictEqual(response.title, title);
+        assert.strictEqual(response.workPhone, workPhone);
+        assert.strictEqual(response.data.length, 0);
+    });
+
+    it('getCurrentUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.getCurrentUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('getCurrentUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.getCurrentUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_get_user.js b/test/mock-api/users/test_get_user.js
new file mode 100644
index 0000000..1f917bc
--- /dev/null
+++ b/test/mock-api/users/test_get_user.js
@@ -0,0 +1,201 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ACCOUNT_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    TEST_MOBILE_PHONE,
+    TEST_EMAIL,
+    TEST_ALTERNATE_EMAIL,
+    TEST_FIRST_NAME,
+    TEST_LAST_NAME,
+    TEST_LAST_LOGIN,
+    TEST_CUSTOM_WELCOME_SCREEN_VIEWED,
+    TEST_SHEET_COUNT,
+    TEST_PROFILE_IMAGE_ID,
+    TEST_PROFILE_IMAGE_HEIGHT,
+    TEST_PROFILE_IMAGE_WIDTH,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - getUser endpoint tests', function () {
+    let client = createClient();
+    const accountId = TEST_ACCOUNT_ID;
+    const accountName = 'Acme Corporation';
+    const company = 'Acme Corporation';
+    const department = 'Engineering';
+    const email = TEST_EMAIL;
+    const firstName = TEST_FIRST_NAME;
+    const jiraAdmin = false;
+    const lastName = TEST_LAST_NAME;
+    const locale = 'en_US';
+    const mobilePhone = TEST_MOBILE_PHONE;
+    const role = 'Senior Developer';
+    const salesforceAdmin = false;
+    const salesforceUser = false;
+    const timeZone = 'US/Pacific';
+    const title = 'Senior Software Engineer';
+    const workPhone = TEST_MOBILE_PHONE;
+    const admin = true;
+    const alternateEmailId = TEST_ALTERNATE_EMAIL_ID;
+    const alternateEmailConfirmed = true;
+    const alternateEmailAddress = TEST_ALTERNATE_EMAIL;
+    const customWelcomeScreenViewed = TEST_CUSTOM_WELCOME_SCREEN_VIEWED;
+    const groupAdmin = true;
+    const lastLogin = TEST_LAST_LOGIN;
+    const licensedSheetCreator = true;
+    const profileImageId = TEST_PROFILE_IMAGE_ID;
+    const profileImageHeight = TEST_PROFILE_IMAGE_HEIGHT;
+    const profileImageWidth = TEST_PROFILE_IMAGE_WIDTH;
+    const resourceViewer = false;
+    const sheetCount = TEST_SHEET_COUNT;
+
+    it('getUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/get-user/all-response-body-properties'
+            }
+        };
+        await client.users.getUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        assert.ok(matchedRequest.url.includes(`/2.0/users/${TEST_USER_ID}`));
+    });
+
+    it('getUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/get-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.getUser(options);
+        
+        // Verify required properties
+        assert.ok(response);
+        assert.strictEqual(response.id, TEST_USER_ID);
+        assert.ok(response.account);
+        assert.strictEqual(response.account.id, accountId);
+        assert.strictEqual(response.account.name, accountName);
+        assert.strictEqual(response.company, company);
+        assert.strictEqual(response.department, department);
+        assert.strictEqual(response.email, email);
+        assert.strictEqual(response.firstName, firstName);
+        assert.strictEqual(response.jiraAdmin, jiraAdmin);
+        assert.strictEqual(response.lastName, lastName);
+        assert.strictEqual(response.locale, locale);
+        assert.strictEqual(response.mobilePhone, mobilePhone);
+        assert.strictEqual(response.role, role);
+        assert.strictEqual(response.salesforceAdmin, salesforceAdmin);
+        assert.strictEqual(response.salesforceUser, salesforceUser);
+        assert.strictEqual(response.timeZone, timeZone);
+        assert.strictEqual(response.title, title);
+        assert.strictEqual(response.workPhone, workPhone);
+
+        // Verify optional properties
+        assert.strictEqual(response.admin, admin);
+        assert.ok(response.alternateEmails);
+        assert.strictEqual(response.alternateEmails.length, 1);
+        assert.strictEqual(response.alternateEmails[0].id, alternateEmailId);
+        assert.strictEqual(response.alternateEmails[0].confirmed, alternateEmailConfirmed);
+        assert.strictEqual(response.alternateEmails[0].email, alternateEmailAddress);
+        assert.strictEqual(response.customWelcomeScreenViewed, customWelcomeScreenViewed);
+        assert.strictEqual(response.groupAdmin, groupAdmin);
+        assert.strictEqual(response.lastLogin, lastLogin);
+        assert.strictEqual(response.licensedSheetCreator, licensedSheetCreator);
+        assert.ok(response.profileImage);
+        assert.strictEqual(response.profileImage.imageId, profileImageId);
+        assert.strictEqual(response.profileImage.height, profileImageHeight);
+        assert.strictEqual(response.profileImage.width, profileImageWidth);
+        assert.strictEqual(response.resourceViewer, resourceViewer);
+        assert.strictEqual(response.sheetCount, sheetCount);
+    });
+
+    it('getUser required response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/get-user/required-response-body-properties'
+            }
+        };
+        const response = await client.users.getUser(options);
+        
+        // Verify required properties
+        assert.ok(response);
+        assert.strictEqual(response.id, TEST_USER_ID);
+        assert.ok(response.account);
+        assert.strictEqual(response.account.id, accountId);
+        assert.strictEqual(response.account.name, accountName);
+        assert.strictEqual(response.company, company);
+        assert.strictEqual(response.department, department);
+        assert.strictEqual(response.email, email);
+        assert.strictEqual(response.firstName, firstName);
+        assert.strictEqual(response.jiraAdmin, jiraAdmin);
+        assert.strictEqual(response.lastName, lastName);
+        assert.strictEqual(response.locale, locale);
+        assert.strictEqual(response.mobilePhone, mobilePhone);
+        assert.strictEqual(response.role, role);
+        assert.strictEqual(response.salesforceAdmin, salesforceAdmin);
+        assert.strictEqual(response.salesforceUser, salesforceUser);
+        assert.strictEqual(response.timeZone, timeZone);
+        assert.strictEqual(response.title, title);
+        assert.strictEqual(response.workPhone, workPhone);
+
+        // Verify optional properties are undefined
+        assert.strictEqual(response.admin, undefined);
+        assert.strictEqual(response.alternateEmails, undefined);
+        assert.strictEqual(response.customWelcomeScreenViewed, undefined);
+        assert.strictEqual(response.groupAdmin, undefined);
+        assert.strictEqual(response.lastLogin, undefined);
+        assert.strictEqual(response.licensedSheetCreator, undefined);
+        assert.strictEqual(response.profileImage, undefined);
+        assert.strictEqual(response.resourceViewer, undefined);
+        assert.strictEqual(response.sheetCount, undefined);
+    });
+
+    it('getUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.getUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('getUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.getUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_list_alternate_emails.js b/test/mock-api/users/test_list_alternate_emails.js
new file mode 100644
index 0000000..2a6e7f1
--- /dev/null
+++ b/test/mock-api/users/test_list_alternate_emails.js
@@ -0,0 +1,94 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    TEST_ALTERNATE_EMAIL,
+    TEST_PAGE_NUMBER,
+    TEST_PAGE_SIZE,
+    TEST_TOTAL_PAGES,
+    TEST_TOTAL_COUNT,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - listAlternateEmails endpoint tests', function () {
+    let client = createClient();
+    const TEST_ALTERNATE_EMAIL_ID_1 = TEST_ALTERNATE_EMAIL_ID;
+    const TEST_EMAIL_1 = TEST_ALTERNATE_EMAIL;
+    const TEST_CONFIRMED_1 = true;
+    it('listAlternateEmails generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/list-alternate-emails/all-response-body-properties'
+            }
+        };
+        await client.users.listAlternateEmails(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/alternateemails`));
+    });
+
+    it('listAlternateEmails all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/list-alternate-emails/all-response-body-properties'
+            }
+        };
+        const response = await client.users.listAlternateEmails(options);
+        assert.ok(response);
+        assert.strictEqual(response.pageNumber, TEST_PAGE_NUMBER);
+        assert.strictEqual(response.pageSize, TEST_PAGE_SIZE);
+        assert.strictEqual(response.totalPages, TEST_TOTAL_PAGES);
+        assert.strictEqual(response.totalCount, TEST_TOTAL_COUNT);
+        assert.strictEqual(response.data.length, 1);
+        assert.strictEqual(response.data[0].id, TEST_ALTERNATE_EMAIL_ID_1);
+        assert.strictEqual(response.data[0].confirmed, TEST_CONFIRMED_1);
+        assert.strictEqual(response.data[0].email, TEST_EMAIL_1);
+    });
+
+    it('listAlternateEmails error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.listAlternateEmails(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('listAlternateEmails error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.listAlternateEmails(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_list_user_plans.js b/test/mock-api/users/test_list_user_plans.js
index 77da72b..9c1eeb7 100644
--- a/test/mock-api/users/test_list_user_plans.js
+++ b/test/mock-api/users/test_list_user_plans.js
@@ -1,15 +1,24 @@
 const assert = require('assert');
 const crypto = require('crypto');
 const { createClient, findWireMockRequest } = require('../utils/utils.js');
-const { TEST_USER_ID, TEST_PLAN_ID } = require('./common_test_constants.js');
+const {
+    TEST_USER_ID,
+    TEST_PLAN_ID,
+    TEST_SEAT_TYPE_LAST_CHANGED_AT,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE,
+    TEST_PROVISIONAL_EXPIRATION_DATE
+} = require('./common_test_constants.js');
 
 describe('Users - listUserPlans endpoint tests', function () {
     const client = createClient();
     const lastKey = '12345678901234569';
     const maxItems = 100;
     const seatType = 'MEMBER';
-    const seatTypeLastChangedAt = '2025-01-01T00:00:00.123456789Z';
-    const provisionalExpirationDate = '2026-12-13T12:17:52.525696Z';
+    const seatTypeLastChangedAt = TEST_SEAT_TYPE_LAST_CHANGED_AT;
+    const provisionalExpirationDate = TEST_PROVISIONAL_EXPIRATION_DATE;
     const isInternalTrue = false;
 
     it('listUserPlans generated url is correct', async function () {
@@ -92,8 +101,8 @@ describe('Users - listUserPlans endpoint tests', function () {
             await client.users.listUserPlans(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 500);
-            assert.strictEqual(error.message, 'Internal Server Error');
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
         }
     });
 
@@ -110,8 +119,8 @@ describe('Users - listUserPlans endpoint tests', function () {
             await client.users.listUserPlans(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 400);
-            assert.strictEqual(error.message, 'Malformed Request');
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
         }
     });
 });
diff --git a/test/mock-api/users/test_list_users.js b/test/mock-api/users/test_list_users.js
index 95d4895..dc4cac4 100644
--- a/test/mock-api/users/test_list_users.js
+++ b/test/mock-api/users/test_list_users.js
@@ -1,30 +1,47 @@
 const assert = require('assert');
 const crypto = require('crypto');
 const { createClient, findWireMockRequest } = require('../utils/utils.js');
-const { TEST_PLAN_ID } = require('./common_test_constants.js');
+const {
+    TEST_PLAN_ID,
+    TEST_EMAIL,
+    TEST_FIRST_NAME,
+    TEST_LAST_NAME,
+    TEST_NAME,
+    TEST_CUSTOM_WELCOME_SCREEN_VIEWED,
+    TEST_LAST_LOGIN,
+    TEST_SEAT_TYPE_LAST_CHANGED_AT,
+    TEST_PAGE_NUMBER,
+    TEST_PAGE_SIZE,
+    TEST_SHEET_COUNT,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE,
+    TEST_PROVISIONAL_EXPIRATION_DATE
+} = require('./common_test_constants.js');
 
 describe('Users - listAllUsers endpoint tests', function () {
     let client = createClient();
-    const emails = 'test.user@smartsheet.com';
+    const emails = TEST_EMAIL;
     const seatType = 'MEMBER';
-    const page = 1;
-    const pageSize = 100;
+    const page = TEST_PAGE_NUMBER;
+    const pageSize = TEST_PAGE_SIZE;
     const includeAll = false;
-    const seatTypeLastChangedAt = '2025-06-14T09:55:30Z';
-    const provisionalExpirationDate = '2026-12-13T12:17:52.525696Z';
+    const seatTypeLastChangedAt = TEST_SEAT_TYPE_LAST_CHANGED_AT;
+    const provisionalExpirationDate = TEST_PROVISIONAL_EXPIRATION_DATE;
     const isInternal = true;
-    const firstName = 'Test';
-    const lastName = 'User';
-    const name = 'Test User';
-    const email = 'test.user@smartsheet.com';
+    const firstName = TEST_FIRST_NAME;
+    const lastName = TEST_LAST_NAME;
+    const name = TEST_NAME;
+    const email = TEST_EMAIL;
     const admin = true;
     const licensedSheetCreator = true;
     const resourceViewer = true;
     const groupAdmin = true;
     const status = 'ACTIVE';
-    const sheetCount = -1;
-    const lastLogin = '2020-10-04T18:32:47Z';
-    const customWelcomeScreenViewed = '2020-08-25T12:15:47Z';
+    const sheetCount = TEST_SHEET_COUNT;
+    const lastLogin = TEST_LAST_LOGIN;
+    const customWelcomeScreenViewed = TEST_CUSTOM_WELCOME_SCREEN_VIEWED;
 
     it('listUsers generated url is correct', async function () {
         const requestId = crypto.randomUUID();
@@ -139,8 +156,8 @@ describe('Users - listAllUsers endpoint tests', function () {
             await client.users.listAllUsers(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 500);
-            assert.strictEqual(error.message, 'Internal Server Error');
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
         }
     });
 
@@ -159,8 +176,8 @@ describe('Users - listAllUsers endpoint tests', function () {
             await client.users.listAllUsers(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 400);
-            assert.strictEqual(error.message, 'Malformed Request');
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
         }
     });
 });
diff --git a/test/mock-api/users/test_make_alternate_email_primary.js b/test/mock-api/users/test_make_alternate_email_primary.js
new file mode 100644
index 0000000..e69554a
--- /dev/null
+++ b/test/mock-api/users/test_make_alternate_email_primary.js
@@ -0,0 +1,94 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_ALTERNATE_EMAIL_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - makeAlternateEmailPrimary endpoint tests', function () {
+    let client = createClient();
+    const TEST_EMAIL = 'alternate.email@smartsheet.com';
+    const TEST_CONFIRMED = true;
+
+    it('makeAlternateEmailPrimary generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/make-alternate-email-primary/all-response-body-properties'
+            }
+        };
+        await client.users.makeAlternateEmailPrimary(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/alternateemails/${TEST_ALTERNATE_EMAIL_ID}/makeprimary`));
+    });
+
+    it('makeAlternateEmailPrimary all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/alternate-emails/make-alternate-email-primary/all-response-body-properties'
+            }
+        };
+        const response = await client.users.makeAlternateEmailPrimary(options);
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.ok(Array.isArray(response.data));
+        assert.strictEqual(response.data.length, 1);
+        assert.strictEqual(response.data[0].id, TEST_ALTERNATE_EMAIL_ID);
+        assert.strictEqual(response.data[0].confirmed, TEST_CONFIRMED);
+        assert.strictEqual(response.data[0].email, TEST_EMAIL);
+    });
+
+    it('makeAlternateEmailPrimary error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.makeAlternateEmailPrimary(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('makeAlternateEmailPrimary error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            alternateEmailId: TEST_ALTERNATE_EMAIL_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.makeAlternateEmailPrimary(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_remove_user.js b/test/mock-api/users/test_remove_user.js
new file mode 100644
index 0000000..cd1a36a
--- /dev/null
+++ b/test/mock-api/users/test_remove_user.js
@@ -0,0 +1,131 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - removeUser endpoint tests', function () {
+    let client = createClient();
+    const transferToUserId = 9876543210987654;
+    const transferSheets = true;
+    const removeFromSharing = true;
+
+    it('removeUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/remove-user/all-response-body-properties'
+            }
+        };
+        await client.users.removeUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/2.0/users/${TEST_USER_ID}`));
+    });
+
+    it('removeUser with query parameters generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            queryParameters: {
+                transferTo: transferToUserId,
+                transferSheets: transferSheets,
+                removeFromSharing: removeFromSharing
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/remove-user/all-response-body-properties'
+            }
+        };
+        await client.users.removeUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/2.0/users/${TEST_USER_ID}`));
+        const queryParams = matchedRequest.queryParams;
+        const transferToActual = parseInt(queryParams.transferTo.values[0]);
+        const transferSheetsActual = queryParams.transferSheets.values[0];
+        const removeFromSharingActual = queryParams.removeFromSharing.values[0];
+        assert.strictEqual(transferToActual, transferToUserId);
+        assert.strictEqual(transferSheetsActual, transferSheets.toString());
+        assert.strictEqual(removeFromSharingActual, removeFromSharing.toString());
+    });
+
+    it('removeUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/remove-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.removeUser(options);
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+    });
+
+    it('removeUser with transferTo all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            queryParameters: {
+                transferTo: transferToUserId,
+                transferSheets: transferSheets
+            },
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/remove-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.removeUser(options);
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+    });
+
+    it('removeUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.removeUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('removeUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.removeUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_remove_user_from_plan.js b/test/mock-api/users/test_remove_user_from_plan.js
index ccc1bce..5ed5682 100644
--- a/test/mock-api/users/test_remove_user_from_plan.js
+++ b/test/mock-api/users/test_remove_user_from_plan.js
@@ -1,7 +1,16 @@
 const assert = require('assert');
 const crypto = require('crypto');
 const { createClient, findWireMockRequest } = require('../utils/utils.js');
-const { TEST_USER_ID, TEST_PLAN_ID } = require('./common_test_constants.js');
+const {
+    TEST_USER_ID,
+    TEST_PLAN_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
 
 describe('Users - removeUserFromPlan endpoint tests', function () {
     let client = createClient();
@@ -34,8 +43,8 @@ describe('Users - removeUserFromPlan endpoint tests', function () {
         };
         const response = await client.users.removeUserFromPlan(options);
         assert.ok(response);
-        assert.strictEqual(response.message, 'SUCCESS');
-        assert.strictEqual(response.resultCode, 0);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
     });
 
     it('removeUserFromPlan error 500 response', async function () {
@@ -52,8 +61,8 @@ describe('Users - removeUserFromPlan endpoint tests', function () {
             await client.users.removeUserFromPlan(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 500);
-            assert.strictEqual(error.message, 'Internal Server Error');
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
         }
     });
 
@@ -71,8 +80,8 @@ describe('Users - removeUserFromPlan endpoint tests', function () {
             await client.users.removeUserFromPlan(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 400);
-            assert.strictEqual(error.message, 'Malformed Request');
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
         }
     });
 });
diff --git a/test/mock-api/users/test_update_user.js b/test/mock-api/users/test_update_user.js
new file mode 100644
index 0000000..e23d422
--- /dev/null
+++ b/test/mock-api/users/test_update_user.js
@@ -0,0 +1,166 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const { createClient, findWireMockRequest } = require('../utils/utils.js');
+const {
+    TEST_USER_ID,
+    TEST_EMAIL,
+    TEST_FIRST_NAME,
+    TEST_LAST_NAME,
+    TEST_NAME,
+    TEST_PROFILE_IMAGE_ID,
+    TEST_PROFILE_IMAGE_HEIGHT,
+    TEST_PROFILE_IMAGE_WIDTH,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
+
+describe('Users - updateUser endpoint tests', function () {
+    let client = createClient();
+    const email = TEST_EMAIL;
+    const firstName = TEST_FIRST_NAME;
+    const lastName = TEST_LAST_NAME;
+    const name = TEST_NAME;
+    const admin = true;
+    const licensedSheetCreator = true;
+    const groupAdmin = false;
+    const resourceViewer = true;
+    const profileImageId = TEST_PROFILE_IMAGE_ID;
+    const profileImageHeight = TEST_PROFILE_IMAGE_HEIGHT;
+    const profileImageWidth = TEST_PROFILE_IMAGE_WIDTH;
+
+    const testUpdateBody = {
+        email: email,
+        firstName: firstName,
+        lastName: lastName,
+        admin: admin,
+        licensedSheetCreator: licensedSheetCreator,
+        groupAdmin: groupAdmin,
+        resourceViewer: resourceViewer
+    };
+
+    it('updateUser generated url is correct', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: testUpdateBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/update-user/all-response-body-properties'
+            }
+        };
+        await client.users.updateUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+
+        assert.ok(matchedRequest.url.includes(`/2.0/users/${TEST_USER_ID}`));
+    });
+
+    it('updateUser all response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: testUpdateBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/update-user/all-response-body-properties'
+            }
+        };
+        const response = await client.users.updateUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.strictEqual(response.data[0].id, TEST_USER_ID);
+        assert.strictEqual(response.data[0].email, email);
+        assert.strictEqual(response.data[0].firstName, firstName);
+        assert.strictEqual(response.data[0].lastName, lastName);
+        assert.strictEqual(response.data[0].name, name);
+        assert.strictEqual(response.data[0].profileImage.imageId, profileImageId);
+        assert.strictEqual(response.data[0].profileImage.height, profileImageHeight);
+        assert.strictEqual(response.data[0].profileImage.width, profileImageWidth);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.strictEqual(body.email, email);
+        assert.strictEqual(body.firstName, firstName);
+        assert.strictEqual(body.lastName, lastName);
+        assert.strictEqual(body.admin, admin);
+        assert.strictEqual(body.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(body.groupAdmin, groupAdmin);
+        assert.strictEqual(body.resourceViewer, resourceViewer);
+    });
+
+    it('updateUser required response body properties', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: testUpdateBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/users/update-user/required-response-body-properties'
+            }
+        };
+        const response = await client.users.updateUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
+        assert.ok(response);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        assert.strictEqual(response.data[0].id, TEST_USER_ID);
+        assert.strictEqual(response.data[0].email, email);
+        assert.strictEqual(response.data[0].firstName, firstName);
+        assert.strictEqual(response.data[0].lastName, lastName);
+        assert.strictEqual(response.data[0].name, name);
+        assert.strictEqual(response.data[0].profileImage, undefined);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.strictEqual(body.email, email);
+        assert.strictEqual(body.firstName, firstName);
+        assert.strictEqual(body.lastName, lastName);
+        assert.strictEqual(body.admin, admin);
+        assert.strictEqual(body.licensedSheetCreator, licensedSheetCreator);
+        assert.strictEqual(body.groupAdmin, groupAdmin);
+        assert.strictEqual(body.resourceViewer, resourceViewer);
+    });
+
+    it('updateUser error 500 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: testUpdateBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/500-response'
+            }
+        };
+        try {
+            await client.users.updateUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
+        }
+    });
+
+    it('updateUser error 400 response', async function () {
+        const requestId = crypto.randomUUID();
+        const options = {
+            userId: TEST_USER_ID,
+            body: testUpdateBody,
+            customProperties: {
+                'x-request-id': requestId,
+                'x-test-name': '/errors/400-response'
+            }
+        };
+        try {
+            await client.users.updateUser(options);
+            assert.fail('Expected an error to be thrown');
+        } catch (error) {
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
+        }
+    });
+});
diff --git a/test/mock-api/users/test_user_upgrade_downgrade.js b/test/mock-api/users/test_user_upgrade_downgrade.js
index 6d2e364..7918da4 100644
--- a/test/mock-api/users/test_user_upgrade_downgrade.js
+++ b/test/mock-api/users/test_user_upgrade_downgrade.js
@@ -1,7 +1,16 @@
 const assert = require('assert');
 const crypto = require('crypto');
 const { createClient, findWireMockRequest } = require('../utils/utils.js');
-const { TEST_USER_ID, TEST_PLAN_ID } = require('./common_test_constants.js');
+const {
+    TEST_USER_ID,
+    TEST_PLAN_ID,
+    TEST_SUCCESS_MESSAGE,
+    TEST_SUCCESS_RESULT_CODE,
+    ERROR_500_STATUS_CODE,
+    ERROR_500_MESSAGE,
+    ERROR_400_STATUS_CODE,
+    ERROR_400_MESSAGE
+} = require('./common_test_constants.js');
 
 describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
     let client = createClient();
@@ -25,8 +34,6 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
         const matchedRequest = await findWireMockRequest(requestId);
 
         assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/plans/${TEST_PLAN_ID}/upgrade`));
-        let body = JSON.parse(matchedRequest.body);
-        assert.deepStrictEqual(body, TEST_UPGRADE_BODY);
     });
 
     it('upgradeUser all response body properties', async function () {
@@ -41,9 +48,14 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
             }
         };
         const response = await client.users.upgradeUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
         assert.ok(response);
-        assert.strictEqual(response.message, 'SUCCESS');
-        assert.strictEqual(response.resultCode, 0);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.deepStrictEqual(body, TEST_UPGRADE_BODY);
     });
 
     it('upgradeUser no seat type passed', async function () {
@@ -58,8 +70,8 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
         };
         const response = await client.users.upgradeUser(options);
         assert.ok(response);
-        assert.strictEqual(response.message, 'SUCCESS');
-        assert.strictEqual(response.resultCode, 0);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
     });
 
     it('upgradeUser error 500 response', async function () {
@@ -77,8 +89,8 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
             await client.users.upgradeUser(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 500);
-            assert.strictEqual(error.message, 'Internal Server Error');
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
         }
     });
 
@@ -97,8 +109,8 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
             await client.users.upgradeUser(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 400);
-            assert.strictEqual(error.message, 'Malformed Request');
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
         }
     });
 
@@ -116,8 +128,6 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
         await client.users.downgradeUser(options);
         const matchedRequest = await findWireMockRequest(requestId);
         assert.ok(matchedRequest.url.includes(`/users/${TEST_USER_ID}/plans/${TEST_PLAN_ID}/downgrade`));
-        let body = JSON.parse(matchedRequest.body);
-        assert.deepStrictEqual(body, TEST_DOWNGRADE_BODY);
     });
 
     it('downgradeUser all response body properties', async function () {
@@ -132,9 +142,14 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
             }
         };
         const response = await client.users.downgradeUser(options);
+        const matchedRequest = await findWireMockRequest(requestId);
+        
         assert.ok(response);
-        assert.strictEqual(response.message, 'SUCCESS');
-        assert.strictEqual(response.resultCode, 0);
+        assert.strictEqual(response.message, TEST_SUCCESS_MESSAGE);
+        assert.strictEqual(response.resultCode, TEST_SUCCESS_RESULT_CODE);
+        
+        let body = JSON.parse(matchedRequest.body);
+        assert.deepStrictEqual(body, TEST_DOWNGRADE_BODY);
     });
 
     it('downgradeUser error 500 response', async function () {
@@ -152,8 +167,8 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
             await client.users.downgradeUser(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 500);
-            assert.strictEqual(error.message, 'Internal Server Error');
+            assert.strictEqual(error.statusCode, ERROR_500_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_500_MESSAGE);
         }
     });
 
@@ -172,8 +187,8 @@ describe('Users - upgradeUser & downgradeUser endpoint tests', function () {
             await client.users.downgradeUser(options);
             assert.fail('Expected an error to be thrown');
         } catch (error) {
-            assert.strictEqual(error.statusCode, 400);
-            assert.strictEqual(error.message, 'Malformed Request');
+            assert.strictEqual(error.statusCode, ERROR_400_STATUS_CODE);
+            assert.strictEqual(error.message, ERROR_400_MESSAGE);
         }
     });
 });