@rudderstack/integrations-lib 0.2.23 → 0.2.25

package/build/sdks/googleAdsRestAPI/googleAds.test.js

@@ -0,0 +1,757 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const axios_1 = __importStar(require("axios"));
+const googleAds_1 = __importDefault(require("./googleAds"));
+describe('Google ads SDK', () => {
+    let mock;
+    beforeEach(() => {
+        mock = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+    });
+    afterEach(() => {
+        mock.restore();
+    });
+    describe('Test getConversionAction function', () => {
+        const testCases = [
+            {
+                name: 'should return conversion action ID when API returns success response',
+                authObject: {
+                    accessToken: 'test-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                mockResponse: [
+                    {
+                        results: [
+                            {
+                                conversionAction: {
+                                    resourceName: 'customers/123456789/conversionActions/9876543',
+                                    id: '9876543',
+                                },
+                            },
+                        ],
+                    },
+                ],
+                conversionName: 'test_conversion',
+                status: 200,
+                expectedResult: 'customers/123456789/conversionActions/9876543',
+                expectedRequest: {
+                    url: '/123456789/googleAds:searchStream',
+                    data: JSON.stringify({
+                        query: "SELECT conversion_action.id FROM conversion_action WHERE conversion_action.name = 'test_conversion'",
+                    }),
+                },
+            },
+            {
+                name: 'handle failure scenario when accessToken is wrong',
+                authObject: {
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    accessToken: 'wrong-access-token',
+                },
+                mockResponse: [
+                    {
+                        error: {
+                            code: 401,
+                            message: 'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',
+                            status: 'UNAUTHENTICATED',
+                        },
+                    },
+                ],
+                mockResponseHeader: new axios_1.AxiosHeaders({
+                    'transfer-encoding': 'chunked',
+                }),
+                conversionName: 'test_conversion',
+                status: 401,
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({
+                        'transfer-encoding': 'chunked',
+                    }),
+                    message: undefined,
+                    responseBody: [
+                        {
+                            error: {
+                                code: 401,
+                                message: 'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',
+                                status: 'UNAUTHENTICATED',
+                            },
+                        },
+                    ],
+                    statusCode: 401,
+                    type: 'application-error',
+                },
+                expectedRequest: {
+                    url: '/123456789/googleAds:searchStream',
+                    data: JSON.stringify({
+                        query: "SELECT conversion_action.id FROM conversion_action WHERE conversion_action.name = 'test_conversion'",
+                    }),
+                },
+            },
+            {
+                name: 'handle the situation when the conversion is not available',
+                authObject: {
+                    accessToken: 'test-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                mockResponse: [],
+                conversionName: 'non-existing-conversion',
+                status: 200,
+                expectedResult: null,
+                expectedRequest: {
+                    url: '/123456789/googleAds:searchStream',
+                    data: JSON.stringify({
+                        query: "SELECT conversion_action.id FROM conversion_action WHERE conversion_action.name = 'non-existing-conversion'",
+                    }),
+                },
+            },
+        ];
+        testCases.forEach(({ name, authObject, mockResponse, conversionName, expectedRequest, expectedResult, status, mockResponseHeader, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789/googleAds:searchStream')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.getConversionActionId(conversionName);
+                expect(mock.history.post[0]).toMatchObject(expectedRequest);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test getCustomVariable function', () => {
+        const testCases = [
+            {
+                name: 'should return an array of CustomVariableResults when API call succeeds',
+                authObject: {
+                    accessToken: 'test-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                mockResponse: [
+                    {
+                        results: [
+                            {
+                                conversionCustomVariable: {
+                                    resourceName: 'customers/123/conversionCustomVariables/456',
+                                    name: 'test_variable',
+                                },
+                            },
+                        ],
+                        fieldMask: 'conversion_custom_variable.name',
+                        requestId: '123456',
+                        queryResourceConsumption: '100',
+                    },
+                ],
+                status: 200,
+                expectedResult: [
+                    {
+                        conversionCustomVariable: {
+                            resourceName: 'customers/123/conversionCustomVariables/456',
+                            name: 'test_variable',
+                        },
+                    },
+                ],
+                expectedRequest: {
+                    url: '/123456789/googleAds:searchStream',
+                    data: JSON.stringify({
+                        query: 'SELECT conversion_custom_variable.name FROM conversion_custom_variable',
+                    }),
+                },
+            },
+            {
+                name: 'should handle the scenario when there is not any customVariables',
+                authObject: {
+                    accessToken: 'test-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                status: 200,
+                mockResponse: [
+                    {
+                        results: [],
+                        fieldMask: 'conversion_custom_variable.name',
+                        requestId: '123456',
+                        queryResourceConsumption: '100',
+                    },
+                ],
+                expectedResult: [],
+                expectedRequest: {
+                    url: '/123456789/googleAds:searchStream',
+                    data: JSON.stringify({
+                        query: 'SELECT conversion_custom_variable.name FROM conversion_custom_variable',
+                    }),
+                },
+            },
+            {
+                name: 'should return an array of CustomVariableResults when API call succeeds',
+                authObject: {
+                    accessToken: 'wrong-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                mockResponse: [
+                    {
+                        error: {
+                            code: 401,
+                            message: 'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',
+                            status: 'UNAUTHENTICATED',
+                        },
+                    },
+                ],
+                status: 401,
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({
+                        'transfer-encoding': 'chunked',
+                    }),
+                    message: undefined,
+                    responseBody: [
+                        {
+                            error: {
+                                code: 401,
+                                message: 'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',
+                                status: 'UNAUTHENTICATED',
+                            },
+                        },
+                    ],
+                    statusCode: 401,
+                    type: 'application-error',
+                },
+                expectedRequest: {
+                    url: '/123456789/googleAds:searchStream',
+                    data: JSON.stringify({
+                        query: 'SELECT conversion_custom_variable.name FROM conversion_custom_variable',
+                    }),
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({
+                    'transfer-encoding': 'chunked',
+                }),
+            },
+        ];
+        testCases.forEach(({ name, authObject, mockResponse, expectedRequest, expectedResult, status, mockResponseHeader, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789/googleAds:searchStream')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.getCustomVariable();
+                expect(mock.history.post[0]).toMatchObject(expectedRequest);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test addConversionAdjustMent function', () => {
+        const TestCases = [
+            {
+                name: 'should successfully upload conversion adjustments with valid data',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                requestData: {
+                    conversionAdjustments: [
+                        {
+                            gclidDateTimePair: {
+                                gclid: 'test-gclid',
+                                conversionDateTime: '2023-01-01T00:00:00Z',
+                            },
+                            adjustmentType: 'RESTATEMENT',
+                            restatementValue: {
+                                adjustedValue: 100,
+                                currencyCode: 'USD',
+                            },
+                            userIdentifiers: [
+                                {
+                                    userIdentifierSource: 'FIRST_PARTY',
+                                    hashedEmail: '389205904d6c7bb83fc676513911226f2be25bf1465616bb9b29587100ab1414',
+                                },
+                            ],
+                        },
+                    ],
+                    partialFailure: false,
+                },
+                status: 200,
+                mockResponse: {
+                    conversionAdjustments: [
+                        {
+                            gclidDateTimePair: {
+                                gclid: 'test-gclid',
+                                conversionDateTime: '2023-01-01T00:00:00Z',
+                            },
+                            adjustmentType: 'RESTATEMENT',
+                            restatementValue: {
+                                adjustedValue: 100,
+                                currencyCode: 'USD',
+                            },
+                            userIdentifiers: [],
+                        },
+                    ],
+                    partialFailure: false,
+                },
+                expectedResult: {
+                    type: 'success',
+                    statusCode: 200,
+                    responseBody: {
+                        conversionAdjustments: [
+                            {
+                                gclidDateTimePair: {
+                                    gclid: 'test-gclid',
+                                    conversionDateTime: '2023-01-01T00:00:00Z',
+                                },
+                                adjustmentType: 'RESTATEMENT',
+                                restatementValue: { adjustedValue: 100, currencyCode: 'USD' },
+                                userIdentifiers: [],
+                            },
+                        ],
+                        partialFailure: false,
+                    },
+                    headers: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+            {
+                name: 'should successfully handle failure scenario',
+                authObject: {
+                    accessToken: 'wrong-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                requestData: {
+                    conversionAdjustments: [
+                        {
+                            gclidDateTimePair: {
+                                gclid: 'test-gclid',
+                                conversionDateTime: '2023-01-01T00:00:00Z',
+                            },
+                            adjustmentType: 'RESTATEMENT',
+                            restatementValue: {
+                                adjustedValue: 100,
+                                currencyCode: 'USD',
+                            },
+                            userIdentifiers: [
+                                {
+                                    userIdentifierSource: 'FIRST_PARTY',
+                                    hashedEmail: '389205904d6c7bb83fc676513911226f2be25bf1465616bb9b29587100ab1414',
+                                },
+                            ],
+                        },
+                    ],
+                    partialFailure: false,
+                },
+                status: 401,
+                mockResponse: {
+                    headers: new axios_1.AxiosHeaders({
+                        'transfer-encoding': 'chunked',
+                    }),
+                    message: undefined,
+                    responseBody: [
+                        {
+                            error: {
+                                code: 401,
+                                message: 'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',
+                                status: 'UNAUTHENTICATED',
+                            },
+                        },
+                    ],
+                    statusCode: 401,
+                    type: 'application-error',
+                },
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({
+                        'Content-Type': 'application/json',
+                    }),
+                    message: undefined,
+                    responseBody: {
+                        headers: { 'transfer-encoding': 'chunked' },
+                        responseBody: [
+                            {
+                                error: {
+                                    code: 401,
+                                    message: 'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',
+                                    status: 'UNAUTHENTICATED',
+                                },
+                            },
+                        ],
+                        statusCode: 401,
+                        type: 'application-error',
+                    },
+                    statusCode: 401,
+                    type: 'application-error',
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, requestData, expectedResult, mockResponseHeader, status, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789:uploadConversionAdjustments')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.addConversionAdjustMent(requestData);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test createOfflineUserDataJob function', () => {
+        const TestCases = [
+            {
+                name: 'should return job ID when response type is success for customerMatchUserList job',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    loginCustomerId: '987654321',
+                },
+                requestData: {
+                    job: {
+                        type: 'CUSTOMER_MATCH_USER_LIST',
+                        customerMatchUserListMetadata: {
+                            userList: 'customers/123456789/userLists/1234',
+                        },
+                    },
+                },
+                status: 200,
+                mockResponse: {
+                    resourceName: 'customers/123456789/offlineUserDataJobs/5678',
+                },
+                expectedResult: '5678',
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+            {
+                name: 'should return job ID when response type is success for store sales job',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                },
+                requestData: {
+                    job: {
+                        storeSalesMetadata: {
+                            custom_key: 'CUSTOM_KEY',
+                            loyaltyFraction: 1,
+                            transaction_upload_fraction: '1',
+                        },
+                        type: 'STORE_SALES_UPLOAD_FIRST_PARTY',
+                    },
+                },
+                status: 200,
+                mockResponse: {
+                    resourceName: 'customers/123456789/offlineUserDataJobs/5678',
+                },
+                expectedResult: '5678',
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, status, requestData, expectedResult, mockResponseHeader, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs:create')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.createOfflineUserDataJob(requestData);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test addUserToOfflineUserDataJob function', () => {
+        const TestCases = [
+            {
+                name: 'should successfully add user data to an offline user data job',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    loginCustomerId: '987654321',
+                },
+                jobId: '1234',
+                requestData: {
+                    operations: [
+                        {
+                            create: {
+                                userIdentifiers: [{ hashedEmail: 'hashed_email_value' }],
+                            },
+                        },
+                    ],
+                    enablePartialFailure: false,
+                },
+                status: 200,
+                mockResponse: {},
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+                    responseBody: {},
+                    statusCode: 200,
+                    type: 'success',
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, status, requestData, expectedResult, mockResponseHeader, jobId, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs/1234:addOperations')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.addUserToOfflineUserDataJob(jobId, requestData);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test addConversionsToOfflineUserDataJob function', () => {
+        const TestCases = [
+            {
+                name: 'should successfully add store sales conversion data to an offline user data job',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    loginCustomerId: '987654321',
+                },
+                jobId: '1234',
+                requestData: {
+                    operations: [
+                        {
+                            create: {
+                                userIdentifiers: [{ hashedEmail: 'hashed-email-value' }],
+                                transactionInfo: {
+                                    conversionAction: 'customers/123456789/conversionActions/987',
+                                    conversionDateTime: '2023-01-01 12:00:00',
+                                    conversionValue: 10.99,
+                                    currencyCode: 'USD',
+                                },
+                            },
+                        },
+                    ],
+                    enablePartialFailure: true,
+                },
+                status: 200,
+                mockResponse: {},
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+                    responseBody: {},
+                    statusCode: 200,
+                    type: 'success',
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, status, requestData, expectedResult, mockResponseHeader, jobId, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs/1234:addOperations')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.addConversionsToOfflineUserDataJob(jobId, requestData);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test runOfflineUserDataJob function', () => {
+        const TestCases = [
+            {
+                name: 'should successfully run an offline user data job with valid jobId',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    loginCustomerId: '987654321',
+                },
+                jobId: '1234',
+                requestData: {},
+                status: 200,
+                mockResponse: {
+                    success: true,
+                    data: { name: 'test-job', done: true },
+                },
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+                    responseBody: {
+                        success: true,
+                        data: { name: 'test-job', done: true },
+                    },
+                    statusCode: 200,
+                    type: 'success',
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, status, expectedResult, mockResponseHeader, jobId }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs/1234:run')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.runOfflineUserDataJob(jobId);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test uploadClickConversion function', () => {
+        const TestCases = [
+            {
+                name: 'should successfully add user data to an offline user data job',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    loginCustomerId: '987654321',
+                },
+                requestData: {
+                    conversions: [
+                        {
+                            gclid: 'test-gclid',
+                            conversionAction: 'test-action',
+                            conversionDateTime: '2023-01-01T00:00:00Z',
+                            conversionValue: 100,
+                            currencyCode: 'USD',
+                        },
+                    ],
+                },
+                status: 200,
+                mockResponse: {
+                    success: true,
+                    data: {
+                        results: [
+                            {
+                                gclid: 'test-gclid',
+                                conversionAction: 'test-action',
+                                conversionDateTime: '2023-01-01T00:00:00Z',
+                            },
+                        ],
+                    },
+                },
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+                    responseBody: {
+                        data: {
+                            results: [
+                                {
+                                    conversionAction: 'test-action',
+                                    conversionDateTime: '2023-01-01T00:00:00Z',
+                                    gclid: 'test-gclid',
+                                },
+                            ],
+                        },
+                        success: true,
+                    },
+                    statusCode: 200,
+                    type: 'success',
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, status, expectedResult, mockResponseHeader, requestData, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789:uploadClickConversions')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.uploadClickConversion(requestData);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('Test uploadCallConversion function', () => {
+        const TestCases = [
+            {
+                name: 'should successfully upload call conversion data and return a successful response',
+                authObject: {
+                    accessToken: 'valid-access-token',
+                    customerId: '123456789',
+                    developerToken: 'test-developer-token',
+                    loginCustomerId: '987654321',
+                },
+                requestData: {
+                    conversions: [
+                        {
+                            callerId: '1234567890',
+                            callStartDateTime: '2023-01-01T12:00:00Z',
+                            conversionAction: 'action1',
+                            conversionDateTime: '2023-01-01T12:05:00Z',
+                        },
+                    ],
+                    partialFailure: false,
+                },
+                status: 200,
+                mockResponse: {
+                    success: true,
+                    data: {
+                        results: [
+                            {
+                                callerId: '1234567890',
+                                callStartDateTime: '2023-01-01T12:00:00Z',
+                                conversionAction: 'action1',
+                                conversionDateTime: '2023-01-01T12:05:00Z',
+                            },
+                        ],
+                    },
+                },
+                expectedResult: {
+                    headers: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+                    responseBody: {
+                        data: {
+                            results: [
+                                {
+                                    callStartDateTime: '2023-01-01T12:00:00Z',
+                                    callerId: '1234567890',
+                                    conversionAction: 'action1',
+                                    conversionDateTime: '2023-01-01T12:05:00Z',
+                                },
+                            ],
+                        },
+                        success: true,
+                    },
+                    statusCode: 200,
+                    type: 'success',
+                },
+                mockResponseHeader: new axios_1.AxiosHeaders({ 'Content-Type': 'application/json' }),
+            },
+        ];
+        TestCases.forEach(({ name, authObject, mockResponse, status, expectedResult, mockResponseHeader, requestData, }) => {
+            it(name, async () => {
+                const googleAds = new googleAds_1.default(authObject);
+                mock
+                    .onPost('https://googleads.googleapis.com/v19/customers/123456789:uploadClickConversions')
+                    .reply(status, mockResponse, mockResponseHeader);
+                const result = await googleAds.uploadClickConversion(requestData);
+                expect(result).toEqual(expectedResult);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"googleAds.test.js","sourceRoot":"","sources":["../../../src/sdks/googleAdsRestAPI/googleAds.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4EAAkD;AAClD,+CAA4C;AAC5C,4DAAoC;AAEpC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,IAAI,IAAsB,CAAC;IAE3B,UAAU,CAAC,GAAG,EAAE;QACd,IAAI,GAAG,IAAI,4BAAgB,CAAC,eAAK,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,mCAAmC,EAAE,GAAG,EAAE;QACjD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,sEAAsE;gBAC5E,UAAU,EAAE;oBACV,WAAW,EAAE,mBAAmB;oBAChC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,YAAY,EAAE;oBACZ;wBACE,OAAO,EAAE;4BACP;gCACE,gBAAgB,EAAE;oCAChB,YAAY,EAAE,+CAA+C;oCAC7D,EAAE,EAAE,SAAS;iCACd;6BACF;yBACF;qBACF;iBACF;gBACD,cAAc,EAAE,iBAAiB;gBACjC,MAAM,EAAE,GAAG;gBACX,cAAc,EAAE,+CAA+C;gBAC/D,eAAe,EAAE;oBACf,GAAG,EAAE,mCAAmC;oBACxC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACnB,KAAK,EACH,qGAAqG;qBACxG,CAAC;iBACH;aACF;YACD;gBACE,IAAI,EAAE,mDAAmD;gBACzD,UAAU,EAAE;oBACV,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,WAAW,EAAE,oBAAoB;iBAClC;gBACD,YAAY,EAAE;oBACZ;wBACE,KAAK,EAAE;4BACL,IAAI,EAAE,GAAG;4BACT,OAAO,EACL,kNAAkN;4BACpN,MAAM,EAAE,iBAAiB;yBAC1B;qBACF;iBACF;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC;oBACnC,mBAAmB,EAAE,SAAS;iBAC/B,CAAC;gBACF,cAAc,EAAE,iBAAiB;gBACjC,MAAM,EAAE,GAAG;gBACX,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC;wBACxB,mBAAmB,EAAE,SAAS;qBAC/B,CAAC;oBACF,OAAO,EAAE,SAAS;oBAClB,YAAY,EAAE;wBACZ;4BACE,KAAK,EAAE;gCACL,IAAI,EAAE,GAAG;gCACT,OAAO,EACL,kNAAkN;gCACpN,MAAM,EAAE,iBAAiB;6BAC1B;yBACF;qBACF;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,mBAAmB;iBAC1B;gBACD,eAAe,EAAE;oBACf,GAAG,EAAE,mCAAmC;oBACxC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACnB,KAAK,EACH,qGAAqG;qBACxG,CAAC;iBACH;aACF;YACD;gBACE,IAAI,EAAE,2DAA2D;gBACjE,UAAU,EAAE;oBACV,WAAW,EAAE,mBAAmB;oBAChC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,YAAY,EAAE,EAAE;gBAChB,cAAc,EAAE,yBAAyB;gBACzC,MAAM,EAAE,GAAG;gBACX,cAAc,EAAE,IAAI;gBACpB,eAAe,EAAE;oBACf,GAAG,EAAE,mCAAmC;oBACxC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACnB,KAAK,EACH,6GAA6G;qBAChH,CAAC;iBACH;aACF;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,cAAc,EACd,eAAe,EACf,cAAc,EACd,MAAM,EACN,kBAAkB,GACnB,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,iFAAiF,CAClF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;gBACrE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;gBAC5D,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAC/C,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,wEAAwE;gBAC9E,UAAU,EAAE;oBACV,WAAW,EAAE,mBAAmB;oBAChC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,YAAY,EAAE;oBACZ;wBACE,OAAO,EAAE;4BACP;gCACE,wBAAwB,EAAE;oCACxB,YAAY,EAAE,6CAA6C;oCAC3D,IAAI,EAAE,eAAe;iCACtB;6BACF;yBACF;wBACD,SAAS,EAAE,iCAAiC;wBAC5C,SAAS,EAAE,QAAQ;wBACnB,wBAAwB,EAAE,KAAK;qBAChC;iBACF;gBACD,MAAM,EAAE,GAAG;gBACX,cAAc,EAAE;oBACd;wBACE,wBAAwB,EAAE;4BACxB,YAAY,EAAE,6CAA6C;4BAC3D,IAAI,EAAE,eAAe;yBACtB;qBACF;iBACF;gBACD,eAAe,EAAE;oBACf,GAAG,EAAE,mCAAmC;oBACxC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACnB,KAAK,EAAE,wEAAwE;qBAChF,CAAC;iBACH;aACF;YACD;gBACE,IAAI,EAAE,kEAAkE;gBACxE,UAAU,EAAE;oBACV,WAAW,EAAE,mBAAmB;oBAChC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ;wBACE,OAAO,EAAE,EAAE;wBACX,SAAS,EAAE,iCAAiC;wBAC5C,SAAS,EAAE,QAAQ;wBACnB,wBAAwB,EAAE,KAAK;qBAChC;iBACF;gBACD,cAAc,EAAE,EAAE;gBAClB,eAAe,EAAE;oBACf,GAAG,EAAE,mCAAmC;oBACxC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACnB,KAAK,EAAE,wEAAwE;qBAChF,CAAC;iBACH;aACF;YACD;gBACE,IAAI,EAAE,wEAAwE;gBAC9E,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,YAAY,EAAE;oBACZ;wBACE,KAAK,EAAE;4BACL,IAAI,EAAE,GAAG;4BACT,OAAO,EACL,kNAAkN;4BACpN,MAAM,EAAE,iBAAiB;yBAC1B;qBACF;iBACF;gBACD,MAAM,EAAE,GAAG;gBACX,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC;wBACxB,mBAAmB,EAAE,SAAS;qBAC/B,CAAC;oBACF,OAAO,EAAE,SAAS;oBAClB,YAAY,EAAE;wBACZ;4BACE,KAAK,EAAE;gCACL,IAAI,EAAE,GAAG;gCACT,OAAO,EACL,kNAAkN;gCACpN,MAAM,EAAE,iBAAiB;6BAC1B;yBACF;qBACF;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,mBAAmB;iBAC1B;gBACD,eAAe,EAAE;oBACf,GAAG,EAAE,mCAAmC;oBACxC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;wBACnB,KAAK,EAAE,wEAAwE;qBAChF,CAAC;iBACH;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC;oBACnC,mBAAmB,EAAE,SAAS;iBAC/B,CAAC;aACH;SACF,CAAC;QAEF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,MAAM,EACN,kBAAkB,GACnB,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,iFAAiF,CAClF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,iBAAiB,EAAE,CAAC;gBACnD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;gBAC5D,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACrD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,mEAAmE;gBACzE,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,WAAW,EAAE;oBACX,qBAAqB,EAAE;wBACrB;4BACE,iBAAiB,EAAE;gCACjB,KAAK,EAAE,YAAY;gCACnB,kBAAkB,EAAE,sBAAsB;6BAC3C;4BACD,cAAc,EAAE,aAAsB;4BACtC,gBAAgB,EAAE;gCAChB,aAAa,EAAE,GAAG;gCAClB,YAAY,EAAE,KAAK;6BACpB;4BACD,eAAe,EAAE;gCACf;oCACE,oBAAoB,EAAE,aAAsB;oCAC5C,WAAW,EAAE,kEAAkE;iCAChF;6BACF;yBACF;qBACF;oBACD,cAAc,EAAE,KAAK;iBACtB;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,qBAAqB,EAAE;wBACrB;4BACE,iBAAiB,EAAE;gCACjB,KAAK,EAAE,YAAY;gCACnB,kBAAkB,EAAE,sBAAsB;6BAC3C;4BACD,cAAc,EAAE,aAAa;4BAC7B,gBAAgB,EAAE;gCAChB,aAAa,EAAE,GAAG;gCAClB,YAAY,EAAE,KAAK;6BACpB;4BACD,eAAe,EAAE,EAAE;yBACpB;qBACF;oBACD,cAAc,EAAE,KAAK;iBACtB;gBACD,cAAc,EAAE;oBACd,IAAI,EAAE,SAAS;oBACf,UAAU,EAAE,GAAG;oBACf,YAAY,EAAE;wBACZ,qBAAqB,EAAE;4BACrB;gCACE,iBAAiB,EAAE;oCACjB,KAAK,EAAE,YAAY;oCACnB,kBAAkB,EAAE,sBAAsB;iCAC3C;gCACD,cAAc,EAAE,aAAa;gCAC7B,gBAAgB,EAAE,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE;gCAC7D,eAAe,EAAE,EAAE;6BACpB;yBACF;wBACD,cAAc,EAAE,KAAK;qBACtB;oBACD,OAAO,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;iBAClE;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;YACD;gBACE,IAAI,EAAE,6CAA6C;gBACnD,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,WAAW,EAAE;oBACX,qBAAqB,EAAE;wBACrB;4BACE,iBAAiB,EAAE;gCACjB,KAAK,EAAE,YAAY;gCACnB,kBAAkB,EAAE,sBAAsB;6BAC3C;4BACD,cAAc,EAAE,aAAsB;4BACtC,gBAAgB,EAAE;gCAChB,aAAa,EAAE,GAAG;gCAClB,YAAY,EAAE,KAAK;6BACpB;4BACD,eAAe,EAAE;gCACf;oCACE,oBAAoB,EAAE,aAAsB;oCAC5C,WAAW,EAAE,kEAAkE;iCAChF;6BACF;yBACF;qBACF;oBACD,cAAc,EAAE,KAAK;iBACtB;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,OAAO,EAAE,IAAI,oBAAY,CAAC;wBACxB,mBAAmB,EAAE,SAAS;qBAC/B,CAAC;oBACF,OAAO,EAAE,SAAS;oBAClB,YAAY,EAAE;wBACZ;4BACE,KAAK,EAAE;gCACL,IAAI,EAAE,GAAG;gCACT,OAAO,EACL,kNAAkN;gCACpN,MAAM,EAAE,iBAAiB;6BAC1B;yBACF;qBACF;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,mBAAmB;iBAC1B;gBACD,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC;wBACxB,cAAc,EAAE,kBAAkB;qBACnC,CAAC;oBACF,OAAO,EAAE,SAAS;oBAClB,YAAY,EAAE;wBACZ,OAAO,EAAE,EAAE,mBAAmB,EAAE,SAAS,EAAE;wBAC3C,YAAY,EAAE;4BACZ;gCACE,KAAK,EAAE;oCACL,IAAI,EAAE,GAAG;oCACT,OAAO,EACL,kNAAkN;oCACpN,MAAM,EAAE,iBAAiB;iCAC1B;6BACF;yBACF;wBACD,UAAU,EAAE,GAAG;wBACf,IAAI,EAAE,mBAAmB;qBAC1B;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,mBAAmB;iBAC1B;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,MAAM,GACP,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,sFAAsF,CACvF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;gBACpE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,wCAAwC,EAAE,GAAG,EAAE;QACtD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,kFAAkF;gBACxF,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,eAAe,EAAE,WAAW;iBAC7B;gBACD,WAAW,EAAE;oBACX,GAAG,EAAE;wBACH,IAAI,EAAE,0BAAmC;wBACzC,6BAA6B,EAAE;4BAC7B,QAAQ,EAAE,oCAAoC;yBAC/C;qBACF;iBACF;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,YAAY,EAAE,8CAA8C;iBAC7D;gBACD,cAAc,EAAE,MAAM;gBACtB,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;YACD;gBACE,IAAI,EAAE,wEAAwE;gBAC9E,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;iBACvC;gBACD,WAAW,EAAE;oBACX,GAAG,EAAE;wBACH,kBAAkB,EAAE;4BAClB,UAAU,EAAE,YAAY;4BACxB,eAAe,EAAE,CAAC;4BAClB,2BAA2B,EAAE,GAAG;yBACjC;wBACD,IAAI,EAAE,gCAAyC;qBAChD;iBACF;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,YAAY,EAAE,8CAA8C;iBAC7D;gBACD,cAAc,EAAE,MAAM;gBACtB,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,WAAW,EACX,cAAc,EACd,kBAAkB,GACnB,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,qFAAqF,CACtF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;gBACrE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACzD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,+DAA+D;gBACrE,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,eAAe,EAAE,WAAW;iBAC7B;gBACD,KAAK,EAAE,MAAM;gBACb,WAAW,EAAE;oBACX,UAAU,EAAE;wBACV;4BACE,MAAM,EAAE;gCACN,eAAe,EAAE,CAAC,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;6BACzD;yBACF;qBACF;oBACD,oBAAoB,EAAE,KAAK;iBAC5B;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE,EAAE;gBAChB,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;oBACjE,YAAY,EAAE,EAAE;oBAChB,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,SAAS;iBAChB;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,KAAK,GACN,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,iGAAiG,CAClG;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,2BAA2B,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;gBAC/E,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAChE,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,iFAAiF;gBACvF,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,eAAe,EAAE,WAAW;iBAC7B;gBACD,KAAK,EAAE,MAAM;gBACb,WAAW,EAAE;oBACX,UAAU,EAAE;wBACV;4BACE,MAAM,EAAE;gCACN,eAAe,EAAE,CAAC,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;gCACxD,eAAe,EAAE;oCACf,gBAAgB,EAAE,2CAA2C;oCAC7D,kBAAkB,EAAE,qBAAqB;oCACzC,eAAe,EAAE,KAAK;oCACtB,YAAY,EAAE,KAAK;iCACpB;6BACF;yBACF;qBACF;oBACD,oBAAoB,EAAE,IAAI;iBAC3B;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE,EAAE;gBAChB,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;oBACjE,YAAY,EAAE,EAAE;oBAChB,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,SAAS;iBAChB;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,KAAK,GACN,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,iGAAiG,CAClG;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,kCAAkC,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;gBACtF,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qCAAqC,EAAE,GAAG,EAAE;QACnD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,mEAAmE;gBACzE,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,eAAe,EAAE,WAAW;iBAC7B;gBACD,KAAK,EAAE,MAAM;gBACb,WAAW,EAAE,EAAE;gBACf,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE;iBACvC;gBACD,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;oBACjE,YAAY,EAAE;wBACZ,OAAO,EAAE,IAAI;wBACb,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE;qBACvC;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,SAAS;iBAChB;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,kBAAkB,EAAE,KAAK,EAAE,EAAE,EAAE;YACxF,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,uFAAuF,CACxF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;gBAC5D,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qCAAqC,EAAE,GAAG,EAAE;QACnD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,+DAA+D;gBACrE,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,eAAe,EAAE,WAAW;iBAC7B;gBACD,WAAW,EAAE;oBACX,WAAW,EAAE;wBACX;4BACE,KAAK,EAAE,YAAY;4BACnB,gBAAgB,EAAE,aAAa;4BAC/B,kBAAkB,EAAE,sBAAsB;4BAC1C,eAAe,EAAE,GAAG;4BACpB,YAAY,EAAE,KAAK;yBACpB;qBACF;iBACF;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACJ,OAAO,EAAE;4BACP;gCACE,KAAK,EAAE,YAAY;gCACnB,gBAAgB,EAAE,aAAa;gCAC/B,kBAAkB,EAAE,sBAAsB;6BAC3C;yBACF;qBACF;iBACF;gBACD,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;oBACjE,YAAY,EAAE;wBACZ,IAAI,EAAE;4BACJ,OAAO,EAAE;gCACP;oCACE,gBAAgB,EAAE,aAAa;oCAC/B,kBAAkB,EAAE,sBAAsB;oCAC1C,KAAK,EAAE,YAAY;iCACpB;6BACF;yBACF;wBACD,OAAO,EAAE,IAAI;qBACd;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,SAAS;iBAChB;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,cAAc,EACd,kBAAkB,EAClB,WAAW,GACZ,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,iFAAiF,CAClF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;gBAClE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAClD,MAAM,SAAS,GAAG;YAChB;gBACE,IAAI,EAAE,kFAAkF;gBACxF,UAAU,EAAE;oBACV,WAAW,EAAE,oBAAoB;oBACjC,UAAU,EAAE,WAAW;oBACvB,cAAc,EAAE,sBAAsB;oBACtC,eAAe,EAAE,WAAW;iBAC7B;gBACD,WAAW,EAAE;oBACX,WAAW,EAAE;wBACX;4BACE,QAAQ,EAAE,YAAY;4BACtB,iBAAiB,EAAE,sBAAsB;4BACzC,gBAAgB,EAAE,SAAS;4BAC3B,kBAAkB,EAAE,sBAAsB;yBAC3C;qBACF;oBACD,cAAc,EAAE,KAAK;iBACtB;gBACD,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE;oBACZ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACJ,OAAO,EAAE;4BACP;gCACE,QAAQ,EAAE,YAAY;gCACtB,iBAAiB,EAAE,sBAAsB;gCACzC,gBAAgB,EAAE,SAAS;gCAC3B,kBAAkB,EAAE,sBAAsB;6BAC3C;yBACF;qBACF;iBACF;gBACD,cAAc,EAAE;oBACd,OAAO,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;oBACjE,YAAY,EAAE;wBACZ,IAAI,EAAE;4BACJ,OAAO,EAAE;gCACP;oCACE,iBAAiB,EAAE,sBAAsB;oCACzC,QAAQ,EAAE,YAAY;oCACtB,gBAAgB,EAAE,SAAS;oCAC3B,kBAAkB,EAAE,sBAAsB;iCAC3C;6BACF;yBACF;wBACD,OAAO,EAAE,IAAI;qBACd;oBACD,UAAU,EAAE,GAAG;oBACf,IAAI,EAAE,SAAS;iBAChB;gBACD,kBAAkB,EAAE,IAAI,oBAAY,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;aAC7E;SACF,CAAC;QACF,SAAS,CAAC,OAAO,CACf,CAAC,EACC,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,cAAc,EACd,kBAAkB,EAClB,WAAW,GACZ,EAAE,EAAE;YACH,EAAE,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAClB,MAAM,SAAS,GAAG,IAAI,mBAAS,CAAC,UAAU,CAAC,CAAC;gBAC5C,IAAI;qBACD,MAAM,CACL,iFAAiF,CAClF;qBACA,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;gBAClE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import AxiosMockAdapter from 'axios-mock-adapter';\nimport axios, { AxiosHeaders } from 'axios';\nimport GoogleAds from './googleAds';\n\ndescribe('Google ads SDK', () => {\n  let mock: AxiosMockAdapter;\n\n  beforeEach(() => {\n    mock = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n  });\n\n  afterEach(() => {\n    mock.restore();\n  });\n  describe('Test getConversionAction function', () => {\n    const testCases = [\n      {\n        name: 'should return conversion action ID when API returns success response',\n        authObject: {\n          accessToken: 'test-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        mockResponse: [\n          {\n            results: [\n              {\n                conversionAction: {\n                  resourceName: 'customers/123456789/conversionActions/9876543',\n                  id: '9876543',\n                },\n              },\n            ],\n          },\n        ],\n        conversionName: 'test_conversion',\n        status: 200,\n        expectedResult: 'customers/123456789/conversionActions/9876543',\n        expectedRequest: {\n          url: '/123456789/googleAds:searchStream',\n          data: JSON.stringify({\n            query:\n              \"SELECT conversion_action.id FROM conversion_action WHERE conversion_action.name = 'test_conversion'\",\n          }),\n        },\n      },\n      {\n        name: 'handle failure scenario when accessToken is wrong',\n        authObject: {\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          accessToken: 'wrong-access-token',\n        },\n        mockResponse: [\n          {\n            error: {\n              code: 401,\n              message:\n                'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',\n              status: 'UNAUTHENTICATED',\n            },\n          },\n        ],\n        mockResponseHeader: new AxiosHeaders({\n          'transfer-encoding': 'chunked',\n        }),\n        conversionName: 'test_conversion',\n        status: 401,\n        expectedResult: {\n          headers: new AxiosHeaders({\n            'transfer-encoding': 'chunked',\n          }),\n          message: undefined,\n          responseBody: [\n            {\n              error: {\n                code: 401,\n                message:\n                  'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',\n                status: 'UNAUTHENTICATED',\n              },\n            },\n          ],\n          statusCode: 401,\n          type: 'application-error',\n        },\n        expectedRequest: {\n          url: '/123456789/googleAds:searchStream',\n          data: JSON.stringify({\n            query:\n              \"SELECT conversion_action.id FROM conversion_action WHERE conversion_action.name = 'test_conversion'\",\n          }),\n        },\n      },\n      {\n        name: 'handle the situation when the conversion is not available',\n        authObject: {\n          accessToken: 'test-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        mockResponse: [],\n        conversionName: 'non-existing-conversion',\n        status: 200,\n        expectedResult: null,\n        expectedRequest: {\n          url: '/123456789/googleAds:searchStream',\n          data: JSON.stringify({\n            query:\n              \"SELECT conversion_action.id FROM conversion_action WHERE conversion_action.name = 'non-existing-conversion'\",\n          }),\n        },\n      },\n    ];\n    testCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        conversionName,\n        expectedRequest,\n        expectedResult,\n        status,\n        mockResponseHeader,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789/googleAds:searchStream',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.getConversionActionId(conversionName);\n          expect(mock.history.post[0]).toMatchObject(expectedRequest);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test getCustomVariable function', () => {\n    const testCases = [\n      {\n        name: 'should return an array of CustomVariableResults when API call succeeds',\n        authObject: {\n          accessToken: 'test-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        mockResponse: [\n          {\n            results: [\n              {\n                conversionCustomVariable: {\n                  resourceName: 'customers/123/conversionCustomVariables/456',\n                  name: 'test_variable',\n                },\n              },\n            ],\n            fieldMask: 'conversion_custom_variable.name',\n            requestId: '123456',\n            queryResourceConsumption: '100',\n          },\n        ],\n        status: 200,\n        expectedResult: [\n          {\n            conversionCustomVariable: {\n              resourceName: 'customers/123/conversionCustomVariables/456',\n              name: 'test_variable',\n            },\n          },\n        ],\n        expectedRequest: {\n          url: '/123456789/googleAds:searchStream',\n          data: JSON.stringify({\n            query: 'SELECT conversion_custom_variable.name FROM conversion_custom_variable',\n          }),\n        },\n      },\n      {\n        name: 'should handle the scenario when there is not any customVariables',\n        authObject: {\n          accessToken: 'test-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        status: 200,\n        mockResponse: [\n          {\n            results: [],\n            fieldMask: 'conversion_custom_variable.name',\n            requestId: '123456',\n            queryResourceConsumption: '100',\n          },\n        ],\n        expectedResult: [],\n        expectedRequest: {\n          url: '/123456789/googleAds:searchStream',\n          data: JSON.stringify({\n            query: 'SELECT conversion_custom_variable.name FROM conversion_custom_variable',\n          }),\n        },\n      },\n      {\n        name: 'should return an array of CustomVariableResults when API call succeeds',\n        authObject: {\n          accessToken: 'wrong-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        mockResponse: [\n          {\n            error: {\n              code: 401,\n              message:\n                'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',\n              status: 'UNAUTHENTICATED',\n            },\n          },\n        ],\n        status: 401,\n        expectedResult: {\n          headers: new AxiosHeaders({\n            'transfer-encoding': 'chunked',\n          }),\n          message: undefined,\n          responseBody: [\n            {\n              error: {\n                code: 401,\n                message:\n                  'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',\n                status: 'UNAUTHENTICATED',\n              },\n            },\n          ],\n          statusCode: 401,\n          type: 'application-error',\n        },\n        expectedRequest: {\n          url: '/123456789/googleAds:searchStream',\n          data: JSON.stringify({\n            query: 'SELECT conversion_custom_variable.name FROM conversion_custom_variable',\n          }),\n        },\n        mockResponseHeader: new AxiosHeaders({\n          'transfer-encoding': 'chunked',\n        }),\n      },\n    ];\n\n    testCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        expectedRequest,\n        expectedResult,\n        status,\n        mockResponseHeader,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789/googleAds:searchStream',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.getCustomVariable();\n          expect(mock.history.post[0]).toMatchObject(expectedRequest);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test addConversionAdjustMent function', () => {\n    const TestCases = [\n      {\n        name: 'should successfully upload conversion adjustments with valid data',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        requestData: {\n          conversionAdjustments: [\n            {\n              gclidDateTimePair: {\n                gclid: 'test-gclid',\n                conversionDateTime: '2023-01-01T00:00:00Z',\n              },\n              adjustmentType: 'RESTATEMENT' as const,\n              restatementValue: {\n                adjustedValue: 100,\n                currencyCode: 'USD',\n              },\n              userIdentifiers: [\n                {\n                  userIdentifierSource: 'FIRST_PARTY' as const,\n                  hashedEmail: '389205904d6c7bb83fc676513911226f2be25bf1465616bb9b29587100ab1414',\n                },\n              ],\n            },\n          ],\n          partialFailure: false,\n        },\n        status: 200,\n        mockResponse: {\n          conversionAdjustments: [\n            {\n              gclidDateTimePair: {\n                gclid: 'test-gclid',\n                conversionDateTime: '2023-01-01T00:00:00Z',\n              },\n              adjustmentType: 'RESTATEMENT',\n              restatementValue: {\n                adjustedValue: 100,\n                currencyCode: 'USD',\n              },\n              userIdentifiers: [],\n            },\n          ],\n          partialFailure: false,\n        },\n        expectedResult: {\n          type: 'success',\n          statusCode: 200,\n          responseBody: {\n            conversionAdjustments: [\n              {\n                gclidDateTimePair: {\n                  gclid: 'test-gclid',\n                  conversionDateTime: '2023-01-01T00:00:00Z',\n                },\n                adjustmentType: 'RESTATEMENT',\n                restatementValue: { adjustedValue: 100, currencyCode: 'USD' },\n                userIdentifiers: [],\n              },\n            ],\n            partialFailure: false,\n          },\n          headers: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n      {\n        name: 'should successfully handle failure scenario',\n        authObject: {\n          accessToken: 'wrong-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        requestData: {\n          conversionAdjustments: [\n            {\n              gclidDateTimePair: {\n                gclid: 'test-gclid',\n                conversionDateTime: '2023-01-01T00:00:00Z',\n              },\n              adjustmentType: 'RESTATEMENT' as const,\n              restatementValue: {\n                adjustedValue: 100,\n                currencyCode: 'USD',\n              },\n              userIdentifiers: [\n                {\n                  userIdentifierSource: 'FIRST_PARTY' as const,\n                  hashedEmail: '389205904d6c7bb83fc676513911226f2be25bf1465616bb9b29587100ab1414',\n                },\n              ],\n            },\n          ],\n          partialFailure: false,\n        },\n        status: 401,\n        mockResponse: {\n          headers: new AxiosHeaders({\n            'transfer-encoding': 'chunked',\n          }),\n          message: undefined,\n          responseBody: [\n            {\n              error: {\n                code: 401,\n                message:\n                  'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',\n                status: 'UNAUTHENTICATED',\n              },\n            },\n          ],\n          statusCode: 401,\n          type: 'application-error',\n        },\n        expectedResult: {\n          headers: new AxiosHeaders({\n            'Content-Type': 'application/json',\n          }),\n          message: undefined,\n          responseBody: {\n            headers: { 'transfer-encoding': 'chunked' },\n            responseBody: [\n              {\n                error: {\n                  code: 401,\n                  message:\n                    'Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.',\n                  status: 'UNAUTHENTICATED',\n                },\n              },\n            ],\n            statusCode: 401,\n            type: 'application-error',\n          },\n          statusCode: 401,\n          type: 'application-error',\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        requestData,\n        expectedResult,\n        mockResponseHeader,\n        status,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789:uploadConversionAdjustments',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.addConversionAdjustMent(requestData);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test createOfflineUserDataJob function', () => {\n    const TestCases = [\n      {\n        name: 'should return job ID when response type is success for customerMatchUserList job',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          loginCustomerId: '987654321',\n        },\n        requestData: {\n          job: {\n            type: 'CUSTOMER_MATCH_USER_LIST' as const,\n            customerMatchUserListMetadata: {\n              userList: 'customers/123456789/userLists/1234',\n            },\n          },\n        },\n        status: 200,\n        mockResponse: {\n          resourceName: 'customers/123456789/offlineUserDataJobs/5678',\n        },\n        expectedResult: '5678',\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n      {\n        name: 'should return job ID when response type is success for store sales job',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n        },\n        requestData: {\n          job: {\n            storeSalesMetadata: {\n              custom_key: 'CUSTOM_KEY',\n              loyaltyFraction: 1,\n              transaction_upload_fraction: '1',\n            },\n            type: 'STORE_SALES_UPLOAD_FIRST_PARTY' as const,\n          },\n        },\n        status: 200,\n        mockResponse: {\n          resourceName: 'customers/123456789/offlineUserDataJobs/5678',\n        },\n        expectedResult: '5678',\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        status,\n        requestData,\n        expectedResult,\n        mockResponseHeader,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs:create',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.createOfflineUserDataJob(requestData);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test addUserToOfflineUserDataJob function', () => {\n    const TestCases = [\n      {\n        name: 'should successfully add user data to an offline user data job',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          loginCustomerId: '987654321',\n        },\n        jobId: '1234',\n        requestData: {\n          operations: [\n            {\n              create: {\n                userIdentifiers: [{ hashedEmail: 'hashed_email_value' }],\n              },\n            },\n          ],\n          enablePartialFailure: false,\n        },\n        status: 200,\n        mockResponse: {},\n        expectedResult: {\n          headers: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n          responseBody: {},\n          statusCode: 200,\n          type: 'success',\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        status,\n        requestData,\n        expectedResult,\n        mockResponseHeader,\n        jobId,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs/1234:addOperations',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.addUserToOfflineUserDataJob(jobId, requestData);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test addConversionsToOfflineUserDataJob function', () => {\n    const TestCases = [\n      {\n        name: 'should successfully add store sales conversion data to an offline user data job',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          loginCustomerId: '987654321',\n        },\n        jobId: '1234',\n        requestData: {\n          operations: [\n            {\n              create: {\n                userIdentifiers: [{ hashedEmail: 'hashed-email-value' }],\n                transactionInfo: {\n                  conversionAction: 'customers/123456789/conversionActions/987',\n                  conversionDateTime: '2023-01-01 12:00:00',\n                  conversionValue: 10.99,\n                  currencyCode: 'USD',\n                },\n              },\n            },\n          ],\n          enablePartialFailure: true,\n        },\n        status: 200,\n        mockResponse: {},\n        expectedResult: {\n          headers: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n          responseBody: {},\n          statusCode: 200,\n          type: 'success',\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        status,\n        requestData,\n        expectedResult,\n        mockResponseHeader,\n        jobId,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs/1234:addOperations',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.addConversionsToOfflineUserDataJob(jobId, requestData);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test runOfflineUserDataJob function', () => {\n    const TestCases = [\n      {\n        name: 'should successfully run an offline user data job with valid jobId',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          loginCustomerId: '987654321',\n        },\n        jobId: '1234',\n        requestData: {},\n        status: 200,\n        mockResponse: {\n          success: true,\n          data: { name: 'test-job', done: true },\n        },\n        expectedResult: {\n          headers: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n          responseBody: {\n            success: true,\n            data: { name: 'test-job', done: true },\n          },\n          statusCode: 200,\n          type: 'success',\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({ name, authObject, mockResponse, status, expectedResult, mockResponseHeader, jobId }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789/offlineUserDataJobs/1234:run',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.runOfflineUserDataJob(jobId);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test uploadClickConversion function', () => {\n    const TestCases = [\n      {\n        name: 'should successfully add user data to an offline user data job',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          loginCustomerId: '987654321',\n        },\n        requestData: {\n          conversions: [\n            {\n              gclid: 'test-gclid',\n              conversionAction: 'test-action',\n              conversionDateTime: '2023-01-01T00:00:00Z',\n              conversionValue: 100,\n              currencyCode: 'USD',\n            },\n          ],\n        },\n        status: 200,\n        mockResponse: {\n          success: true,\n          data: {\n            results: [\n              {\n                gclid: 'test-gclid',\n                conversionAction: 'test-action',\n                conversionDateTime: '2023-01-01T00:00:00Z',\n              },\n            ],\n          },\n        },\n        expectedResult: {\n          headers: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n          responseBody: {\n            data: {\n              results: [\n                {\n                  conversionAction: 'test-action',\n                  conversionDateTime: '2023-01-01T00:00:00Z',\n                  gclid: 'test-gclid',\n                },\n              ],\n            },\n            success: true,\n          },\n          statusCode: 200,\n          type: 'success',\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        status,\n        expectedResult,\n        mockResponseHeader,\n        requestData,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789:uploadClickConversions',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.uploadClickConversion(requestData);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n\n  describe('Test uploadCallConversion function', () => {\n    const TestCases = [\n      {\n        name: 'should successfully upload call conversion data and return a successful response',\n        authObject: {\n          accessToken: 'valid-access-token',\n          customerId: '123456789',\n          developerToken: 'test-developer-token',\n          loginCustomerId: '987654321',\n        },\n        requestData: {\n          conversions: [\n            {\n              callerId: '1234567890',\n              callStartDateTime: '2023-01-01T12:00:00Z',\n              conversionAction: 'action1',\n              conversionDateTime: '2023-01-01T12:05:00Z',\n            },\n          ],\n          partialFailure: false,\n        },\n        status: 200,\n        mockResponse: {\n          success: true,\n          data: {\n            results: [\n              {\n                callerId: '1234567890',\n                callStartDateTime: '2023-01-01T12:00:00Z',\n                conversionAction: 'action1',\n                conversionDateTime: '2023-01-01T12:05:00Z',\n              },\n            ],\n          },\n        },\n        expectedResult: {\n          headers: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n          responseBody: {\n            data: {\n              results: [\n                {\n                  callStartDateTime: '2023-01-01T12:00:00Z',\n                  callerId: '1234567890',\n                  conversionAction: 'action1',\n                  conversionDateTime: '2023-01-01T12:05:00Z',\n                },\n              ],\n            },\n            success: true,\n          },\n          statusCode: 200,\n          type: 'success',\n        },\n        mockResponseHeader: new AxiosHeaders({ 'Content-Type': 'application/json' }),\n      },\n    ];\n    TestCases.forEach(\n      ({\n        name,\n        authObject,\n        mockResponse,\n        status,\n        expectedResult,\n        mockResponseHeader,\n        requestData,\n      }) => {\n        it(name, async () => {\n          const googleAds = new GoogleAds(authObject);\n          mock\n            .onPost(\n              'https://googleads.googleapis.com/v19/customers/123456789:uploadClickConversions',\n            )\n            .reply(status, mockResponse, mockResponseHeader);\n          const result = await googleAds.uploadClickConversion(requestData);\n          expect(result).toEqual(expectedResult);\n        });\n      },\n    );\n  });\n});\n"]}