@rudderstack/integrations-lib 0.2.13 → 0.2.15

package/build/sdks/sfmc/index.test.js

@@ -0,0 +1,741 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const _1 = __importDefault(require("."));
+const utils = __importStar(require("./utils"));
+describe('sfmc', () => {
+    describe('getAccessToken', () => {
+        it('should return existing authObject when token is not expired', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            sfmcClient.authObject = validAuthObject;
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const result = await sfmcClient.getAccessToken();
+            expect(result).toBe(validAuthObject);
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+        // Handles case when authObject is initially empty or null
+        it('should request new token when authObject is empty', async () => {
+            const emptyAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+            };
+            const newAuthObject = {
+                ...emptyAuthObject,
+                access_token: 'new-token',
+                expires_in: 12345,
+            };
+            const sfmcClient = new _1.default(emptyAuthObject);
+            sfmcClient.authObject = emptyAuthObject;
+            jest.spyOn(utils, 'isExpired').mockReturnValue(true);
+            // jest.spyOn(axios, 'getToken').mockResolvedValue(newAuthObject);
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.auth.marketingcloudapis.com/v2/token')
+                .reply(200, newAuthObject);
+            jest.spyOn(process, 'hrtime').mockImplementation(() => [0, 0]);
+            const result = await sfmcClient.getAccessToken();
+            expect(result).toEqual({ ...newAuthObject, expiration: 12345 });
+            expect(utils.isExpired).toHaveBeenCalledWith(emptyAuthObject);
+            expect(utils.getToken).toHaveBeenCalledWith(emptyAuthObject);
+        });
+        it('should throw error when authObject has invalid clientId', () => {
+            const invalidAuthObject = {
+                clientId: null,
+                clientSecret: 'test-secret',
+                subDomain: 'test',
+            };
+            try {
+                const sfmcInstance = new _1.default(invalidAuthObject);
+                sfmcInstance.getAccessToken();
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('clientId is missing or invalid'));
+            }
+        });
+        it('should handle concurrent token refresh requests correctly', async () => {
+            const emptyAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+            };
+            const newAuthObject = {
+                ...emptyAuthObject,
+                access_token: 'new-token',
+                expires_in: 12345,
+            };
+            const sfmcClient = new _1.default(emptyAuthObject);
+            sfmcClient.authObject = emptyAuthObject;
+            jest.spyOn(utils, 'isExpired').mockReturnValue(true);
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.auth.marketingcloudapis.com/v2/token')
+                .reply(200, newAuthObject);
+            jest.spyOn(process, 'hrtime').mockImplementation(() => [0, 0]);
+            let result = await sfmcClient.getAccessToken();
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            result = await sfmcClient.getAccessToken();
+            expect(result).toEqual({ ...newAuthObject, expiration: 12345 });
+            expect(utils.isExpired).toHaveBeenCalledWith(emptyAuthObject);
+            expect(utils.isExpired).toHaveBeenCalledWith(emptyAuthObject);
+        });
+        it('should throw error with original message when token request fails', async () => {
+            const emptyAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+            };
+            const sfmcClient = new _1.default(emptyAuthObject);
+            sfmcClient.authObject = emptyAuthObject;
+            jest.spyOn(utils, 'isExpired').mockReturnValue(true);
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.auth.marketingcloudapis.com/v2/token')
+                .reply(400, new Error('Bad Request'));
+            try {
+                await sfmcClient.getAccessToken();
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Unable to generate token, with error:Error: Request failed with status code 400'));
+            }
+        });
+    });
+    describe('getDestinationFields', () => {
+        it('should return data extension fields', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            const validResponse = {
+                name: 'Test DE',
+                categoryID: '12345',
+                fields: [
+                    {
+                        name: 'field1',
+                        type: 'Text',
+                    },
+                ],
+            };
+            mockAdapter
+                .onGet('https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects/test-de-id/fields')
+                .reply(200, validResponse);
+            const result = await sfmcClient.getDestinationFields('test-de-id');
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+            expect(result).toStrictEqual(validResponse);
+        });
+        it('should handle failure scenario', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onGet('https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects/test-de-id/fields')
+                .reply(401, {
+                documentation: 'https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/error-handling.htm',
+                errorcode: 0,
+                message: 'Not Authorized',
+            });
+            try {
+                await sfmcClient.getDestinationFields('test-de-id');
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Not Authorized'));
+            }
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('getContactAttributes', () => {
+        it('should return contact attributes', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            const validResponse = {
+                data: {
+                    items: [
+                        {
+                            isReadOnly: true,
+                            attributes: [
+                                {
+                                    isReadOnly: true,
+                                    fullyQualifiedName: 'test.name',
+                                    dataType: 'string',
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            mockAdapter
+                .onGet('https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/contacts/v1/attributeSetDefinitions')
+                .reply(200, validResponse);
+            const result = await sfmcClient.getContactAttributes();
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+            expect(result).toStrictEqual(validResponse);
+        });
+        it('should handle failure scenario', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onGet('https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/contacts/v1/attributeSetDefinitions')
+                .reply(401, {
+                documentation: 'https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/error-handling.htm',
+                errorcode: 0,
+                message: 'Not Authorized',
+            });
+            try {
+                await sfmcClient.getContactAttributes();
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Not Authorized'));
+            }
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('createDataExtension', () => {
+        it('should create new data extension', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            const validResponse = {
+                id: '4baf4cf1-8cc9-ef11-ba6e-f40343d380c8',
+                name: 'rudderstackTesting0295',
+                key: 'rudderstackTesting0295',
+                isActive: true,
+                isSendable: false,
+                isTestable: false,
+                status: 0,
+                categoryId: 12345,
+                ownerId: 735444531,
+                isObjectDeletable: true,
+                isFieldAdditionAllowed: true,
+                isFieldModificationAllowed: true,
+                createdDate: '2025-01-02T22:41:12.5018415-06:00',
+                createdById: 735444531,
+                modifiedDate: '2025-01-02T22:41:12.5018415-06:00',
+                modifiedById: 735444531,
+                ownerName: 'RudderstackIntegration app user',
+                rowCount: 0,
+                dataRetentionProperties: {
+                    isDeleteAtEndOfRetentionPeriod: true,
+                    isRowBasedRetention: false,
+                    isResetRetentionPeriodOnImport: false,
+                    rowBasedThreshold: 1000000000,
+                },
+                fields: [
+                    {
+                        name: 'key1',
+                        id: '300ba233-b7e0-4732-ba85-1bc01208fc1b',
+                        type: 'Text',
+                        maskType: 'None',
+                        storageType: 'Plain',
+                        length: 254,
+                        ordinal: 0,
+                        isNullable: false,
+                        isPrimaryKey: true,
+                        isTemplateField: false,
+                        isInheritable: false,
+                        isOverridable: true,
+                        isHidden: false,
+                        isReadOnly: false,
+                        mustOverride: false,
+                    },
+                    {
+                        name: 'key2',
+                        id: '75a38f98-e865-43ce-9702-5b317ba29d92',
+                        type: 'EmailAddress',
+                        maskType: 'None',
+                        storageType: 'Plain',
+                        length: 254,
+                        ordinal: 0,
+                        isNullable: true,
+                        isPrimaryKey: false,
+                        isTemplateField: false,
+                        isInheritable: false,
+                        isOverridable: true,
+                        isHidden: false,
+                        isReadOnly: false,
+                        mustOverride: false,
+                    },
+                ],
+                fieldCount: 2,
+            };
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects')
+                .reply(200, validResponse);
+            const result = await sfmcClient.createDataExtension({
+                name: 'test-de',
+                categoryID: '12345',
+                dataRetentionProperties: {
+                    isDeleteAtEndOfRetentionPeriod: true,
+                    isRowBasedRetention: false,
+                    isResetRetentionPeriodOnImport: false,
+                },
+                fields: [
+                    {
+                        name: 'key1',
+                        type: 'Text',
+                        length: 254,
+                        isNullable: false,
+                        isPrimaryKey: true,
+                        isHidden: false,
+                        isReadOnly: false,
+                        isOverridable: true,
+                        isTemplateField: false,
+                        isInheritable: false,
+                        mustOverride: false,
+                        ordinal: 0,
+                    },
+                    {
+                        name: 'key2',
+                        type: 'EmailAddress',
+                        length: 254,
+                        isNullable: true,
+                        isPrimaryKey: false,
+                        isHidden: false,
+                        isReadOnly: false,
+                        isOverridable: true,
+                        isTemplateField: false,
+                        isInheritable: false,
+                        mustOverride: false,
+                        ordinal: 0,
+                    },
+                ],
+            });
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+            expect(result).toStrictEqual(validResponse);
+        });
+        it('should handle failure scenario', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects')
+                .reply(401, {
+                documentation: 'https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/error-handling.htm',
+                errorcode: 0,
+                message: 'Not Authorized',
+            });
+            try {
+                await sfmcClient.createDataExtension({
+                    name: 'test-de',
+                    categoryID: '12345',
+                    fields: [
+                        {
+                            name: 'key1',
+                            type: 'Text',
+                            length: 254,
+                            isNullable: false,
+                            isPrimaryKey: true,
+                            isHidden: false,
+                            isReadOnly: false,
+                            isOverridable: true,
+                            isTemplateField: false,
+                            isInheritable: false,
+                            mustOverride: false,
+                            ordinal: 0,
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Not Authorized'));
+            }
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('getBusinessUnits', () => {
+        it('should get all the business units', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            const validResponse = `<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"><soap:Header><wsa:Action>RetrieveResponse</wsa:Action><wsa:MessageID>urn:uuid:0bed602b-63c4-4bb4-9582-2b27c8f2b1da</wsa:MessageID><wsa:RelatesTo>urn:uuid:45dcc251-a037-4172-99ce-666a6b3b872c</wsa:RelatesTo><wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To><wsse:Security><wsu:Timestamp wsu:Id="Timestamp-d0308ae2-4adf-4578-8d85-faa720a966ce"><wsu:Created>2025-01-09T05:50:10Z</wsu:Created><wsu:Expires>2025-01-09T05:55:10Z</wsu:Expires></wsu:Timestamp></wsse:Security></soap:Header><soap:Body><RetrieveResponseMsg xmlns="http://exacttarget.com/wsdl/partnerAPI"><OverallStatus>OK</OverallStatus><RequestID>ab947caa-34bd-4e5b-84c1-54ab1e633a6f</RequestID><Results xsi:type="BusinessUnit"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>id</Name><Value>534003210</Value></PartnerProperties><PartnerProperties><Name>name</Name><Value>Lansdowne Stadium LP</Value></PartnerProperties><ObjectID xsi:nil="true" /><AccountType>None</AccountType><Subscription xsi:nil="true" /></Results><Results xsi:type="BusinessUnit"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>id</Name><Value>534003210</Value></PartnerProperties><PartnerProperties><Name>name</Name><Value>Lansdowne Stadium LP</Value></PartnerProperties><ObjectID xsi:nil="true" /><AccountType>None</AccountType><Subscription xsi:nil="true" /></Results></RetrieveResponseMsg></soap:Body></soap:Envelope>`;
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')
+                .reply(200, validResponse);
+            const result = await sfmcClient.getBusinessUnits();
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+            expect(result).toStrictEqual([
+                { ID: 'Lansdowne Stadium LP', Name: 534003210 },
+                { ID: 'Lansdowne Stadium LP', Name: 534003210 },
+            ]);
+        });
+        it('should handle failure scenario', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')
+                .reply(500, `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">
+    <soap:Header>
+        <wsa:Action>http://schemas.xmlsoap.org/ws/2004/08/addressing/fault</wsa:Action>
+        <wsa:MessageID>urn:uuid:15d3e286-97f5-4f5c-b0fa-d58673621568</wsa:MessageID>
+        <wsa:RelatesTo>urn:uuid:b38ee85b-8f6b-4edc-9ab9-23ab6e5a51e3</wsa:RelatesTo>
+        <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
+        <wsse:Security>
+            <wsu:Timestamp wsu:Id="Timestamp-dc02f8e8-af74-4799-b5e9-9e9c0299278f">
+                <wsu:Created>2025-01-03T04:59:45Z</wsu:Created>
+                <wsu:Expires>2025-01-03T05:04:45Z</wsu:Expires>
+            </wsu:Timestamp>
+        </wsse:Security>
+    </soap:Header>
+    <soap:Body>
+        <soap:Fault>
+            <faultcode xmlns:q0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">q0:Security</faultcode>
+            <faultstring>Login Failed</faultstring>
+            <faultactor>https://mcvgkqz3c1chrbsz586k90s41hp8.soap.marketingcloudapis.com/Service.asmx</faultactor>
+        </soap:Fault>
+    </soap:Body>
+</soap:Envelope>`);
+            try {
+                await sfmcClient.getBusinessUnits();
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Request failed with status code 500'));
+            }
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('getDataFolders', () => {
+        it('should get all the data folders', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            const validResponse = `<?xml version="1.0" encoding="utf-8"?>
+        <soap:Envelope
+          xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+          xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing"
+          xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+          xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">
+          <soap:Header>
+            <wsa:Action>RetrieveResponse</wsa:Action>
+            <wsa:MessageID>urn:uuid:1cf4fd72-93a9-4360-a75c-988dc708eb7c</wsa:MessageID>
+            <wsa:RelatesTo>urn:uuid:527a13a5-a798-4438-b23d-b7fd084ac953</wsa:RelatesTo>
+            <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
+            <wsse:Security>
+              <wsu:Timestamp wsu:Id="Timestamp-9d7c5707-e8ec-4db8-b55e-7cbd2ce22fa3">
+                <wsu:Created>2025-01-03T05:54:16Z</wsu:Created>
+                <wsu:Expires>2025-01-03T05:59:16Z</wsu:Expires>
+              </wsu:Timestamp>
+            </wsse:Security>
+          </soap:Header>
+          <soap:Body>
+            <RetrieveResponseMsg
+              xmlns="http://exacttarget.com/wsdl/partnerAPI">
+              <OverallStatus>OK</OverallStatus>
+              <RequestID>5d91708b-25d1-4b27-80a0-dc84ef0aac0c</RequestID>
+              <Results xsi:type="DataFolder">
+                <Client>
+                  <ID>534003210</ID>
+                </Client>
+                <PartnerKey xsi:nil="true" />
+                <ID>11546</ID>
+                <ObjectID>4f591ca1-8236-47b8-92fe-cf0dcf7cffb5</ObjectID>
+                <Name>my emails</Name>
+                <Description />
+                <ContentType>email</ContentType>
+              </Results>
+              <Results xsi:type="DataFolder">
+                <Client>
+                  <ID>534003210</ID>
+                </Client>
+                <PartnerKey xsi:nil="true" />
+                <ID>11547</ID>
+                <ObjectID>695dd7c6-d764-479d-9e77-36d141cdd342</ObjectID>
+                <Name>simple automated emails</Name>
+                <Description />
+                <ContentType>automated_email</ContentType>
+              </Results>
+            </RetrieveResponseMsg>
+          </soap:Body>
+        </soap:Envelope>`;
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')
+                .reply(200, validResponse);
+            const result = await sfmcClient.getDataFolders();
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+            expect(result).toStrictEqual([
+                {
+                    Client: {
+                        ID: 534003210,
+                    },
+                    ContentType: 'email',
+                    Description: '',
+                    ID: 11546,
+                    Name: 'my emails',
+                    ObjectID: '4f591ca1-8236-47b8-92fe-cf0dcf7cffb5',
+                    PartnerKey: '',
+                },
+                {
+                    Client: {
+                        ID: 534003210,
+                    },
+                    ContentType: 'automated_email',
+                    Description: '',
+                    ID: 11547,
+                    Name: 'simple automated emails',
+                    ObjectID: '695dd7c6-d764-479d-9e77-36d141cdd342',
+                    PartnerKey: '',
+                },
+            ]);
+        });
+        it('should handle failure scenario', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')
+                .reply(500, `<?xml version="1.0" encoding="utf-8"?>
+          <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">
+              <soap:Header>
+                  <wsa:Action>http://schemas.xmlsoap.org/ws/2004/08/addressing/fault</wsa:Action>
+                  <wsa:MessageID>urn:uuid:15d3e286-97f5-4f5c-b0fa-d58673621568</wsa:MessageID>
+                  <wsa:RelatesTo>urn:uuid:b38ee85b-8f6b-4edc-9ab9-23ab6e5a51e3</wsa:RelatesTo>
+                  <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
+                  <wsse:Security>
+                      <wsu:Timestamp wsu:Id="Timestamp-dc02f8e8-af74-4799-b5e9-9e9c0299278f">
+                          <wsu:Created>2025-01-03T04:59:45Z</wsu:Created>
+                          <wsu:Expires>2025-01-03T05:04:45Z</wsu:Expires>
+                      </wsu:Timestamp>
+                  </wsse:Security>
+              </soap:Header>
+              <soap:Body>
+                  <soap:Fault>
+                      <faultcode xmlns:q0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">q0:Security</faultcode>
+                      <faultstring>Login Failed</faultstring>
+                      <faultactor>https://mcvgkqz3c1chrbsz586k90s41hp8.soap.marketingcloudapis.com/Service.asmx</faultactor>
+                  </soap:Fault>
+              </soap:Body>
+          </soap:Envelope>`);
+            try {
+                await sfmcClient.getDataFolders();
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Request failed with status code 500'));
+            }
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('getDataExtensions', () => {
+        it('should get all the data extensions', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            const validResponse = `<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"><soap:Header><wsa:Action>RetrieveResponse</wsa:Action><wsa:MessageID>urn:uuid:0214d595-39f2-42bb-b18f-782e3aec9125</wsa:MessageID><wsa:RelatesTo>urn:uuid:8c9f1fe6-584a-492f-ad1e-b62887e6b27d</wsa:RelatesTo><wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To><wsse:Security><wsu:Timestamp wsu:Id="Timestamp-749c5b90-7c3e-405e-a891-4cab9aa319d5"><wsu:Created>2025-01-09T10:01:15Z</wsu:Created><wsu:Expires>2025-01-09T10:06:15Z</wsu:Expires></wsu:Timestamp></wsse:Security></soap:Header><soap:Body><RetrieveResponseMsg xmlns="http://exacttarget.com/wsdl/partnerAPI"><OverallStatus>OK</OverallStatus><RequestID>26123846-4046-430b-89dc-9e5c2eb587fd</RequestID><Results xsi:type="DataExtension"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>ObjectId</Name><Value>b30e26db-5e59-ef11-ba6d-f40343ce89d8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting13342</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil="true" /></Results><Results xsi:type="DataExtension"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>ObjectId</Name><Value>191c5b2a-57b8-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>TestFromSDK1234</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil="true" /></Results><Results xsi:type="DataExtension"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>ObjectId</Name><Value>503856e3-5ab8-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting121120</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil="true" /></Results><Results xsi:type="DataExtension"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>ObjectId</Name><Value>1742f6f1-79b8-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting12442</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil="true" /></Results><Results xsi:type="DataExtension"><PartnerKey xsi:nil="true" /><PartnerProperties><Name>ObjectId</Name><Value>4baf4cf1-8cc9-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting0295</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil="true" /></Results></RetrieveResponseMsg></soap:Body></soap:Envelope>`;
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')
+                .reply(200, validResponse);
+            const result = await sfmcClient.getDataExtensions('valid-folder-id');
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+            expect(result).toStrictEqual([
+                {
+                    CategoryId: 12345,
+                    Name: 'rudderstackTesting13342',
+                    ObjectId: 'b30e26db-5e59-ef11-ba6d-f40343ce89d8',
+                },
+                {
+                    CategoryId: 12345,
+                    Name: 'TestFromSDK1234',
+                    ObjectId: '191c5b2a-57b8-ef11-ba6e-f40343d380c8',
+                },
+                {
+                    CategoryId: 12345,
+                    Name: 'rudderstackTesting121120',
+                    ObjectId: '503856e3-5ab8-ef11-ba6e-f40343d380c8',
+                },
+                {
+                    CategoryId: 12345,
+                    Name: 'rudderstackTesting12442',
+                    ObjectId: '1742f6f1-79b8-ef11-ba6e-f40343d380c8',
+                },
+                {
+                    CategoryId: 12345,
+                    Name: 'rudderstackTesting0295',
+                    ObjectId: '4baf4cf1-8cc9-ef11-ba6e-f40343d380c8',
+                },
+            ]);
+        });
+        it('should handle failure scenario', async () => {
+            const validAuthObject = {
+                clientId: 'test-client',
+                clientSecret: 'test-secret',
+                subDomain: 'abcdefghijklmnopqrstuvwxyz01',
+                access_token: 'valid-token',
+                expiration: process.hrtime()[0] + 3600,
+            };
+            const sfmcClient = new _1.default(validAuthObject);
+            jest.spyOn(utils, 'isExpired').mockReturnValue(false);
+            const requestTokenSpy = jest.spyOn(utils, 'getToken');
+            const mockAdapter = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+            mockAdapter
+                .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')
+                .reply(500, `<?xml version="1.0" encoding="utf-8"?>
+          <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">
+              <soap:Header>
+                  <wsa:Action>http://schemas.xmlsoap.org/ws/2004/08/addressing/fault</wsa:Action>
+                  <wsa:MessageID>urn:uuid:15d3e286-97f5-4f5c-b0fa-d58673621568</wsa:MessageID>
+                  <wsa:RelatesTo>urn:uuid:b38ee85b-8f6b-4edc-9ab9-23ab6e5a51e3</wsa:RelatesTo>
+                  <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
+                  <wsse:Security>
+                      <wsu:Timestamp wsu:Id="Timestamp-dc02f8e8-af74-4799-b5e9-9e9c0299278f">
+                          <wsu:Created>2025-01-03T04:59:45Z</wsu:Created>
+                          <wsu:Expires>2025-01-03T05:04:45Z</wsu:Expires>
+                      </wsu:Timestamp>
+                  </wsse:Security>
+              </soap:Header>
+              <soap:Body>
+                  <soap:Fault>
+                      <faultcode xmlns:q0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">q0:Security</faultcode>
+                      <faultstring>Login Failed</faultstring>
+                      <faultactor>https://mcvgkqz3c1chrbsz586k90s41hp8.soap.marketingcloudapis.com/Service.asmx</faultactor>
+                  </soap:Fault>
+              </soap:Body>
+          </soap:Envelope>`);
+            try {
+                await sfmcClient.getDataExtensions();
+            }
+            catch (e) {
+                expect(e).toEqual(new Error('Request failed with status code 500'));
+            }
+            expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);
+            expect(requestTokenSpy).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.test.js","sourceRoot":"","sources":["../../../src/sdks/sfmc/index.test.ts"],"names":[],"mappings":"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","sourcesContent":["import axios from 'axios';\nimport AxiosMockAdapter from 'axios-mock-adapter';\nimport SFMC from '.';\nimport * as utils from './utils';\n\ndescribe('sfmc', () => {\n  describe('getAccessToken', () => {\n    it('should return existing authObject when token is not expired', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n      sfmcClient.authObject = validAuthObject;\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n      const result = await sfmcClient.getAccessToken();\n\n      expect(result).toBe(validAuthObject);\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n    // Handles case when authObject is initially empty or null\n    it('should request new token when authObject is empty', async () => {\n      const emptyAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n      };\n\n      const newAuthObject = {\n        ...emptyAuthObject,\n        access_token: 'new-token',\n        expires_in: 12345,\n      };\n\n      const sfmcClient = new SFMC(emptyAuthObject);\n      sfmcClient.authObject = emptyAuthObject;\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(true);\n      // jest.spyOn(axios, 'getToken').mockResolvedValue(newAuthObject);\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.auth.marketingcloudapis.com/v2/token')\n        .reply(200, newAuthObject);\n      jest.spyOn(process, 'hrtime').mockImplementation(() => [0, 0]);\n      const result = await sfmcClient.getAccessToken();\n      expect(result).toEqual({ ...newAuthObject, expiration: 12345 });\n      expect(utils.isExpired).toHaveBeenCalledWith(emptyAuthObject);\n      expect(utils.getToken).toHaveBeenCalledWith(emptyAuthObject);\n    });\n    it('should throw error when authObject has invalid clientId', () => {\n      const invalidAuthObject = {\n        clientId: null,\n        clientSecret: 'test-secret',\n        subDomain: 'test',\n      };\n      try {\n        const sfmcInstance = new SFMC(invalidAuthObject);\n        sfmcInstance.getAccessToken();\n      } catch (e) {\n        expect(e).toEqual(new Error('clientId is missing or invalid'));\n      }\n    });\n    it('should handle concurrent token refresh requests correctly', async () => {\n      const emptyAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n      };\n\n      const newAuthObject = {\n        ...emptyAuthObject,\n        access_token: 'new-token',\n        expires_in: 12345,\n      };\n\n      const sfmcClient = new SFMC(emptyAuthObject);\n      sfmcClient.authObject = emptyAuthObject;\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(true);\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.auth.marketingcloudapis.com/v2/token')\n        .reply(200, newAuthObject);\n      jest.spyOn(process, 'hrtime').mockImplementation(() => [0, 0]);\n      let result = await sfmcClient.getAccessToken();\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      result = await sfmcClient.getAccessToken();\n      expect(result).toEqual({ ...newAuthObject, expiration: 12345 });\n      expect(utils.isExpired).toHaveBeenCalledWith(emptyAuthObject);\n      expect(utils.isExpired).toHaveBeenCalledWith(emptyAuthObject);\n    });\n    it('should throw error with original message when token request fails', async () => {\n      const emptyAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n      };\n\n      const sfmcClient = new SFMC(emptyAuthObject);\n      sfmcClient.authObject = emptyAuthObject;\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(true);\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.auth.marketingcloudapis.com/v2/token')\n        .reply(400, new Error('Bad Request'));\n      try {\n        await sfmcClient.getAccessToken();\n      } catch (e) {\n        expect(e).toEqual(\n          new Error(\n            'Unable to generate token, with error:Error: Request failed with status code 400',\n          ),\n        );\n      }\n    });\n  });\n  describe('getDestinationFields', () => {\n    it('should return data extension fields', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      const validResponse = {\n        name: 'Test DE',\n        categoryID: '12345',\n        fields: [\n          {\n            name: 'field1',\n            type: 'Text',\n          },\n        ],\n      };\n      mockAdapter\n        .onGet(\n          'https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects/test-de-id/fields',\n        )\n        .reply(200, validResponse);\n      const result = await sfmcClient.getDestinationFields('test-de-id');\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n      expect(result).toStrictEqual(validResponse);\n    });\n    it('should handle failure scenario', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onGet(\n          'https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects/test-de-id/fields',\n        )\n        .reply(401, {\n          documentation:\n            'https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/error-handling.htm',\n          errorcode: 0,\n          message: 'Not Authorized',\n        });\n      try {\n        await sfmcClient.getDestinationFields('test-de-id');\n      } catch (e) {\n        expect(e).toEqual(new Error('Not Authorized'));\n      }\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n  });\n  describe('getContactAttributes', () => {\n    it('should return contact attributes', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      const validResponse = {\n        data: {\n          items: [\n            {\n              isReadOnly: true,\n              attributes: [\n                {\n                  isReadOnly: true,\n                  fullyQualifiedName: 'test.name',\n                  dataType: 'string',\n                },\n              ],\n            },\n          ],\n        },\n      };\n      mockAdapter\n        .onGet(\n          'https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/contacts/v1/attributeSetDefinitions',\n        )\n        .reply(200, validResponse);\n      const result = await sfmcClient.getContactAttributes();\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n      expect(result).toStrictEqual(validResponse);\n    });\n    it('should handle failure scenario', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onGet(\n          'https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/contacts/v1/attributeSetDefinitions',\n        )\n        .reply(401, {\n          documentation:\n            'https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/error-handling.htm',\n          errorcode: 0,\n          message: 'Not Authorized',\n        });\n      try {\n        await sfmcClient.getContactAttributes();\n      } catch (e) {\n        expect(e).toEqual(new Error('Not Authorized'));\n      }\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n  });\n  describe('createDataExtension', () => {\n    it('should create new data extension', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      const validResponse = {\n        id: '4baf4cf1-8cc9-ef11-ba6e-f40343d380c8',\n        name: 'rudderstackTesting0295',\n        key: 'rudderstackTesting0295',\n        isActive: true,\n        isSendable: false,\n        isTestable: false,\n        status: 0,\n        categoryId: 12345,\n        ownerId: 735444531,\n        isObjectDeletable: true,\n        isFieldAdditionAllowed: true,\n        isFieldModificationAllowed: true,\n        createdDate: '2025-01-02T22:41:12.5018415-06:00',\n        createdById: 735444531,\n        modifiedDate: '2025-01-02T22:41:12.5018415-06:00',\n        modifiedById: 735444531,\n        ownerName: 'RudderstackIntegration app user',\n        rowCount: 0,\n        dataRetentionProperties: {\n          isDeleteAtEndOfRetentionPeriod: true,\n          isRowBasedRetention: false,\n          isResetRetentionPeriodOnImport: false,\n          rowBasedThreshold: 1000000000,\n        },\n        fields: [\n          {\n            name: 'key1',\n            id: '300ba233-b7e0-4732-ba85-1bc01208fc1b',\n            type: 'Text',\n            maskType: 'None',\n            storageType: 'Plain',\n            length: 254,\n            ordinal: 0,\n            isNullable: false,\n            isPrimaryKey: true,\n            isTemplateField: false,\n            isInheritable: false,\n            isOverridable: true,\n            isHidden: false,\n            isReadOnly: false,\n            mustOverride: false,\n          },\n          {\n            name: 'key2',\n            id: '75a38f98-e865-43ce-9702-5b317ba29d92',\n            type: 'EmailAddress',\n            maskType: 'None',\n            storageType: 'Plain',\n            length: 254,\n            ordinal: 0,\n            isNullable: true,\n            isPrimaryKey: false,\n            isTemplateField: false,\n            isInheritable: false,\n            isOverridable: true,\n            isHidden: false,\n            isReadOnly: false,\n            mustOverride: false,\n          },\n        ],\n        fieldCount: 2,\n      };\n      mockAdapter\n        .onPost(\n          'https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects',\n        )\n        .reply(200, validResponse);\n      const result = await sfmcClient.createDataExtension({\n        name: 'test-de',\n        categoryID: '12345',\n        dataRetentionProperties: {\n          isDeleteAtEndOfRetentionPeriod: true,\n          isRowBasedRetention: false,\n          isResetRetentionPeriodOnImport: false,\n        },\n        fields: [\n          {\n            name: 'key1',\n            type: 'Text',\n            length: 254,\n            isNullable: false,\n            isPrimaryKey: true,\n            isHidden: false,\n            isReadOnly: false,\n            isOverridable: true,\n            isTemplateField: false,\n            isInheritable: false,\n            mustOverride: false,\n            ordinal: 0,\n          },\n          {\n            name: 'key2',\n            type: 'EmailAddress',\n            length: 254,\n            isNullable: true,\n            isPrimaryKey: false,\n            isHidden: false,\n            isReadOnly: false,\n            isOverridable: true,\n            isTemplateField: false,\n            isInheritable: false,\n            mustOverride: false,\n            ordinal: 0,\n          },\n        ],\n      });\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n      expect(result).toStrictEqual(validResponse);\n    });\n    it('should handle failure scenario', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost(\n          'https://abcdefghijklmnopqrstuvwxyz01.rest.marketingcloudapis.com/data/v1/customobjects',\n        )\n        .reply(401, {\n          documentation:\n            'https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/error-handling.htm',\n          errorcode: 0,\n          message: 'Not Authorized',\n        });\n      try {\n        await sfmcClient.createDataExtension({\n          name: 'test-de',\n          categoryID: '12345',\n          fields: [\n            {\n              name: 'key1',\n              type: 'Text',\n              length: 254,\n              isNullable: false,\n              isPrimaryKey: true,\n              isHidden: false,\n              isReadOnly: false,\n              isOverridable: true,\n              isTemplateField: false,\n              isInheritable: false,\n              mustOverride: false,\n              ordinal: 0,\n            },\n          ],\n        });\n      } catch (e) {\n        expect(e).toEqual(new Error('Not Authorized'));\n      }\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n  });\n  describe('getBusinessUnits', () => {\n    it('should get all the business units', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      const validResponse = `<?xml version=\"1.0\" encoding=\"utf-8\"?><soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><soap:Header><wsa:Action>RetrieveResponse</wsa:Action><wsa:MessageID>urn:uuid:0bed602b-63c4-4bb4-9582-2b27c8f2b1da</wsa:MessageID><wsa:RelatesTo>urn:uuid:45dcc251-a037-4172-99ce-666a6b3b872c</wsa:RelatesTo><wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To><wsse:Security><wsu:Timestamp wsu:Id=\"Timestamp-d0308ae2-4adf-4578-8d85-faa720a966ce\"><wsu:Created>2025-01-09T05:50:10Z</wsu:Created><wsu:Expires>2025-01-09T05:55:10Z</wsu:Expires></wsu:Timestamp></wsse:Security></soap:Header><soap:Body><RetrieveResponseMsg xmlns=\"http://exacttarget.com/wsdl/partnerAPI\"><OverallStatus>OK</OverallStatus><RequestID>ab947caa-34bd-4e5b-84c1-54ab1e633a6f</RequestID><Results xsi:type=\"BusinessUnit\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>id</Name><Value>534003210</Value></PartnerProperties><PartnerProperties><Name>name</Name><Value>Lansdowne Stadium LP</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /><AccountType>None</AccountType><Subscription xsi:nil=\"true\" /></Results><Results xsi:type=\"BusinessUnit\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>id</Name><Value>534003210</Value></PartnerProperties><PartnerProperties><Name>name</Name><Value>Lansdowne Stadium LP</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /><AccountType>None</AccountType><Subscription xsi:nil=\"true\" /></Results></RetrieveResponseMsg></soap:Body></soap:Envelope>`;\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')\n        .reply(200, validResponse);\n      const result = await sfmcClient.getBusinessUnits();\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n      expect(result).toStrictEqual([\n        { ID: 'Lansdowne Stadium LP', Name: 534003210 },\n        { ID: 'Lansdowne Stadium LP', Name: 534003210 },\n      ]);\n    });\n    it('should handle failure scenario', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')\n        .reply(\n          500,\n          `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">\n    <soap:Header>\n        <wsa:Action>http://schemas.xmlsoap.org/ws/2004/08/addressing/fault</wsa:Action>\n        <wsa:MessageID>urn:uuid:15d3e286-97f5-4f5c-b0fa-d58673621568</wsa:MessageID>\n        <wsa:RelatesTo>urn:uuid:b38ee85b-8f6b-4edc-9ab9-23ab6e5a51e3</wsa:RelatesTo>\n        <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>\n        <wsse:Security>\n            <wsu:Timestamp wsu:Id=\"Timestamp-dc02f8e8-af74-4799-b5e9-9e9c0299278f\">\n                <wsu:Created>2025-01-03T04:59:45Z</wsu:Created>\n                <wsu:Expires>2025-01-03T05:04:45Z</wsu:Expires>\n            </wsu:Timestamp>\n        </wsse:Security>\n    </soap:Header>\n    <soap:Body>\n        <soap:Fault>\n            <faultcode xmlns:q0=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">q0:Security</faultcode>\n            <faultstring>Login Failed</faultstring>\n            <faultactor>https://mcvgkqz3c1chrbsz586k90s41hp8.soap.marketingcloudapis.com/Service.asmx</faultactor>\n        </soap:Fault>\n    </soap:Body>\n</soap:Envelope>`,\n        );\n      try {\n        await sfmcClient.getBusinessUnits();\n      } catch (e) {\n        expect(e).toEqual(new Error('Request failed with status code 500'));\n      }\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n  });\n  describe('getDataFolders', () => {\n    it('should get all the data folders', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      const validResponse = `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n        <soap:Envelope\n          xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"\n          xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n          xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"\n          xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\"\n          xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"\n          xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">\n          <soap:Header>\n            <wsa:Action>RetrieveResponse</wsa:Action>\n            <wsa:MessageID>urn:uuid:1cf4fd72-93a9-4360-a75c-988dc708eb7c</wsa:MessageID>\n            <wsa:RelatesTo>urn:uuid:527a13a5-a798-4438-b23d-b7fd084ac953</wsa:RelatesTo>\n            <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>\n            <wsse:Security>\n              <wsu:Timestamp wsu:Id=\"Timestamp-9d7c5707-e8ec-4db8-b55e-7cbd2ce22fa3\">\n                <wsu:Created>2025-01-03T05:54:16Z</wsu:Created>\n                <wsu:Expires>2025-01-03T05:59:16Z</wsu:Expires>\n              </wsu:Timestamp>\n            </wsse:Security>\n          </soap:Header>\n          <soap:Body>\n            <RetrieveResponseMsg\n              xmlns=\"http://exacttarget.com/wsdl/partnerAPI\">\n              <OverallStatus>OK</OverallStatus>\n              <RequestID>5d91708b-25d1-4b27-80a0-dc84ef0aac0c</RequestID>\n              <Results xsi:type=\"DataFolder\">\n                <Client>\n                  <ID>534003210</ID>\n                </Client>\n                <PartnerKey xsi:nil=\"true\" />\n                <ID>11546</ID>\n                <ObjectID>4f591ca1-8236-47b8-92fe-cf0dcf7cffb5</ObjectID>\n                <Name>my emails</Name>\n                <Description />\n                <ContentType>email</ContentType>\n              </Results>\n              <Results xsi:type=\"DataFolder\">\n                <Client>\n                  <ID>534003210</ID>\n                </Client>\n                <PartnerKey xsi:nil=\"true\" />\n                <ID>11547</ID>\n                <ObjectID>695dd7c6-d764-479d-9e77-36d141cdd342</ObjectID>\n                <Name>simple automated emails</Name>\n                <Description />\n                <ContentType>automated_email</ContentType>\n              </Results>\n            </RetrieveResponseMsg>\n          </soap:Body>\n        </soap:Envelope>`;\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')\n        .reply(200, validResponse);\n      const result = await sfmcClient.getDataFolders();\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n      expect(result).toStrictEqual([\n        {\n          Client: {\n            ID: 534003210,\n          },\n          ContentType: 'email',\n          Description: '',\n          ID: 11546,\n          Name: 'my emails',\n          ObjectID: '4f591ca1-8236-47b8-92fe-cf0dcf7cffb5',\n          PartnerKey: '',\n        },\n        {\n          Client: {\n            ID: 534003210,\n          },\n          ContentType: 'automated_email',\n          Description: '',\n          ID: 11547,\n          Name: 'simple automated emails',\n          ObjectID: '695dd7c6-d764-479d-9e77-36d141cdd342',\n          PartnerKey: '',\n        },\n      ]);\n    });\n    it('should handle failure scenario', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')\n        .reply(\n          500,\n          `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n          <soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">\n              <soap:Header>\n                  <wsa:Action>http://schemas.xmlsoap.org/ws/2004/08/addressing/fault</wsa:Action>\n                  <wsa:MessageID>urn:uuid:15d3e286-97f5-4f5c-b0fa-d58673621568</wsa:MessageID>\n                  <wsa:RelatesTo>urn:uuid:b38ee85b-8f6b-4edc-9ab9-23ab6e5a51e3</wsa:RelatesTo>\n                  <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>\n                  <wsse:Security>\n                      <wsu:Timestamp wsu:Id=\"Timestamp-dc02f8e8-af74-4799-b5e9-9e9c0299278f\">\n                          <wsu:Created>2025-01-03T04:59:45Z</wsu:Created>\n                          <wsu:Expires>2025-01-03T05:04:45Z</wsu:Expires>\n                      </wsu:Timestamp>\n                  </wsse:Security>\n              </soap:Header>\n              <soap:Body>\n                  <soap:Fault>\n                      <faultcode xmlns:q0=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">q0:Security</faultcode>\n                      <faultstring>Login Failed</faultstring>\n                      <faultactor>https://mcvgkqz3c1chrbsz586k90s41hp8.soap.marketingcloudapis.com/Service.asmx</faultactor>\n                  </soap:Fault>\n              </soap:Body>\n          </soap:Envelope>`,\n        );\n      try {\n        await sfmcClient.getDataFolders();\n      } catch (e) {\n        expect(e).toEqual(new Error('Request failed with status code 500'));\n      }\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n  });\n  describe('getDataExtensions', () => {\n    it('should get all the data extensions', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      const validResponse = `<?xml version=\"1.0\" encoding=\"utf-8\"?><soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><soap:Header><wsa:Action>RetrieveResponse</wsa:Action><wsa:MessageID>urn:uuid:0214d595-39f2-42bb-b18f-782e3aec9125</wsa:MessageID><wsa:RelatesTo>urn:uuid:8c9f1fe6-584a-492f-ad1e-b62887e6b27d</wsa:RelatesTo><wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To><wsse:Security><wsu:Timestamp wsu:Id=\"Timestamp-749c5b90-7c3e-405e-a891-4cab9aa319d5\"><wsu:Created>2025-01-09T10:01:15Z</wsu:Created><wsu:Expires>2025-01-09T10:06:15Z</wsu:Expires></wsu:Timestamp></wsse:Security></soap:Header><soap:Body><RetrieveResponseMsg xmlns=\"http://exacttarget.com/wsdl/partnerAPI\"><OverallStatus>OK</OverallStatus><RequestID>26123846-4046-430b-89dc-9e5c2eb587fd</RequestID><Results xsi:type=\"DataExtension\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>ObjectId</Name><Value>b30e26db-5e59-ef11-ba6d-f40343ce89d8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting13342</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /></Results><Results xsi:type=\"DataExtension\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>ObjectId</Name><Value>191c5b2a-57b8-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>TestFromSDK1234</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /></Results><Results xsi:type=\"DataExtension\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>ObjectId</Name><Value>503856e3-5ab8-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting121120</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /></Results><Results xsi:type=\"DataExtension\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>ObjectId</Name><Value>1742f6f1-79b8-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting12442</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /></Results><Results xsi:type=\"DataExtension\"><PartnerKey xsi:nil=\"true\" /><PartnerProperties><Name>ObjectId</Name><Value>4baf4cf1-8cc9-ef11-ba6e-f40343d380c8</Value></PartnerProperties><PartnerProperties><Name>NAME</Name><Value>rudderstackTesting0295</Value></PartnerProperties><PartnerProperties><Name>CategoryId</Name><Value>12345</Value></PartnerProperties><ObjectID xsi:nil=\"true\" /></Results></RetrieveResponseMsg></soap:Body></soap:Envelope>`;\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')\n        .reply(200, validResponse);\n      const result = await sfmcClient.getDataExtensions('valid-folder-id');\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n      expect(result).toStrictEqual([\n        {\n          CategoryId: 12345,\n          Name: 'rudderstackTesting13342',\n          ObjectId: 'b30e26db-5e59-ef11-ba6d-f40343ce89d8',\n        },\n        {\n          CategoryId: 12345,\n          Name: 'TestFromSDK1234',\n          ObjectId: '191c5b2a-57b8-ef11-ba6e-f40343d380c8',\n        },\n        {\n          CategoryId: 12345,\n          Name: 'rudderstackTesting121120',\n          ObjectId: '503856e3-5ab8-ef11-ba6e-f40343d380c8',\n        },\n        {\n          CategoryId: 12345,\n          Name: 'rudderstackTesting12442',\n          ObjectId: '1742f6f1-79b8-ef11-ba6e-f40343d380c8',\n        },\n        {\n          CategoryId: 12345,\n          Name: 'rudderstackTesting0295',\n          ObjectId: '4baf4cf1-8cc9-ef11-ba6e-f40343d380c8',\n        },\n      ]);\n    });\n    it('should handle failure scenario', async () => {\n      const validAuthObject = {\n        clientId: 'test-client',\n        clientSecret: 'test-secret',\n        subDomain: 'abcdefghijklmnopqrstuvwxyz01',\n        access_token: 'valid-token',\n        expiration: process.hrtime()[0] + 3600,\n      };\n\n      const sfmcClient = new SFMC(validAuthObject);\n\n      jest.spyOn(utils, 'isExpired').mockReturnValue(false);\n      const requestTokenSpy = jest.spyOn(utils, 'getToken');\n\n      const mockAdapter = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n      mockAdapter\n        .onPost('https://abcdefghijklmnopqrstuvwxyz01.soap.marketingcloudapis.com/Service.asmx')\n        .reply(\n          500,\n          `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n          <soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">\n              <soap:Header>\n                  <wsa:Action>http://schemas.xmlsoap.org/ws/2004/08/addressing/fault</wsa:Action>\n                  <wsa:MessageID>urn:uuid:15d3e286-97f5-4f5c-b0fa-d58673621568</wsa:MessageID>\n                  <wsa:RelatesTo>urn:uuid:b38ee85b-8f6b-4edc-9ab9-23ab6e5a51e3</wsa:RelatesTo>\n                  <wsa:To>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>\n                  <wsse:Security>\n                      <wsu:Timestamp wsu:Id=\"Timestamp-dc02f8e8-af74-4799-b5e9-9e9c0299278f\">\n                          <wsu:Created>2025-01-03T04:59:45Z</wsu:Created>\n                          <wsu:Expires>2025-01-03T05:04:45Z</wsu:Expires>\n                      </wsu:Timestamp>\n                  </wsse:Security>\n              </soap:Header>\n              <soap:Body>\n                  <soap:Fault>\n                      <faultcode xmlns:q0=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">q0:Security</faultcode>\n                      <faultstring>Login Failed</faultstring>\n                      <faultactor>https://mcvgkqz3c1chrbsz586k90s41hp8.soap.marketingcloudapis.com/Service.asmx</faultactor>\n                  </soap:Fault>\n              </soap:Body>\n          </soap:Envelope>`,\n        );\n      try {\n        await sfmcClient.getDataExtensions();\n      } catch (e) {\n        expect(e).toEqual(new Error('Request failed with status code 500'));\n      }\n      expect(utils.isExpired).toHaveBeenCalledWith(validAuthObject);\n      expect(requestTokenSpy).not.toHaveBeenCalled();\n    });\n  });\n});\n"]}