@datadog/datadog-ci 2.40.1 → 2.40.2

package/dist/commands/lambda/__tests__/functions/commons.test.js

@@ -0,0 +1,791 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('fs');
+jest.mock('@aws-sdk/credential-providers');
+jest.mock('../../renderers/instrument-uninstrument-renderer');
+const fs = __importStar(require("fs"));
+const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const aws_sdk_client_mock_1 = require("aws-sdk-client-mock");
+require("aws-sdk-client-mock-jest");
+const constants_1 = require("../../../../constants");
+const fixtures_1 = require("../../../../helpers/__tests__/fixtures");
+const constants_2 = require("../../constants");
+const commons_1 = require("../../functions/commons");
+const instrument_1 = require("../../instrument");
+const fixtures_2 = require("../fixtures");
+describe('commons', () => {
+    const cloudWatchLogsClientMock = (0, aws_sdk_client_mock_1.mockClient)(client_cloudwatch_logs_1.CloudWatchLogsClient);
+    const lambdaClientMock = (0, aws_sdk_client_mock_1.mockClient)(client_lambda_1.LambdaClient);
+    beforeEach(() => {
+        cloudWatchLogsClientMock.reset();
+        lambdaClientMock.reset();
+        (0, fixtures_2.mockLambdaClientCommands)(lambdaClientMock);
+    });
+    describe('addLayerArn', () => {
+        test('adds layers and removes previous versions', () => {
+            const runtime = 'python3.9';
+            const config = {
+                Runtime: runtime,
+            };
+            let layerARNs = [
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39:48',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension:10',
+            ];
+            const region = 'sa-east-1';
+            const lambdaLibraryLayerName = constants_2.LAYER_LOOKUP[runtime];
+            const fullLambdaLibraryLayerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region) + ':49';
+            const fullExtensionLayerArn = (0, commons_1.getLayerArn)(config, constants_2.EXTENSION_LAYER_KEY, region) + ':11';
+            layerARNs = (0, commons_1.addLayerArn)(fullLambdaLibraryLayerArn, lambdaLibraryLayerName, layerARNs);
+            layerARNs = (0, commons_1.addLayerArn)(fullExtensionLayerArn, constants_2.DD_LAMBDA_EXTENSION_LAYER_NAME, layerARNs);
+            expect(layerARNs).toEqual([
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39:49',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension:11',
+            ]);
+        });
+        test('swaps layers if architecture is arm64', () => {
+            const runtime = client_lambda_1.Runtime.python39;
+            const config = {
+                Architectures: [client_lambda_1.Architecture.arm64],
+                Runtime: runtime,
+            };
+            let layerARNs = [
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39:49',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension:11',
+            ];
+            const region = 'sa-east-1';
+            const lambdaLibraryLayerName = constants_2.LAYER_LOOKUP[runtime];
+            const fullLambdaLibraryLayerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region) + ':49';
+            const fullExtensionLayerArn = (0, commons_1.getLayerArn)(config, constants_2.EXTENSION_LAYER_KEY, region) + ':11';
+            layerARNs = (0, commons_1.addLayerArn)(fullLambdaLibraryLayerArn, lambdaLibraryLayerName, layerARNs);
+            layerARNs = (0, commons_1.addLayerArn)(fullExtensionLayerArn, constants_2.DD_LAMBDA_EXTENSION_LAYER_NAME, layerARNs);
+            expect(layerARNs).toEqual([
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Python39-ARM:49',
+                'arn:aws:lambda:sa-east-1:464622532012:layer:Datadog-Extension-ARM:11',
+            ]);
+        });
+    });
+    describe('coerceBoolean', () => {
+        test('return fallback when none of the values provided can be parsed to boolean', () => {
+            expect((0, commons_1.coerceBoolean)(true, 'NotBoolean', 123, [], {})).toBe(true);
+            expect((0, commons_1.coerceBoolean)(false, 'NotBooleanEither', 456, ['An array'], { booleanInObject: true })).toBe(false);
+        });
+        test('return the first boolean when one of the values provided can be parsed to boolean', () => {
+            expect((0, commons_1.coerceBoolean)(true, 'false', 'true')).toBe(false);
+            expect((0, commons_1.coerceBoolean)(false, 'true', 'False')).toBe(true);
+        });
+        test('return the first boolean when one of the values provided is boolean', () => {
+            expect((0, commons_1.coerceBoolean)(true, false, 'truE', true)).toBe(false);
+            expect((0, commons_1.coerceBoolean)(false, true, 'False', false)).toBe(true);
+        });
+    });
+    describe('collectFunctionsByRegion', () => {
+        test('groups functions with region read from arn', () => {
+            process.env = {};
+            const command = (0, fixtures_1.createCommand)(instrument_1.InstrumentCommand);
+            const region = 'us-east-1';
+            command['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:us-east-1:123456789012:function:another',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            expect((0, commons_1.collectFunctionsByRegion)(command['functions'], region)).toEqual({
+                'us-east-1': [
+                    'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                    'arn:aws:lambda:us-east-1:123456789012:function:another',
+                ],
+                'us-east-2': ['arn:aws:lambda:us-east-2:123456789012:function:third-func'],
+            });
+        });
+        test('groups functions in the config object', () => {
+            process.env = {};
+            const command = (0, fixtures_1.createCommand)(instrument_1.InstrumentCommand);
+            const region = 'us-east-1';
+            command['config']['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:us-east-1:123456789012:function:another',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            expect((0, commons_1.collectFunctionsByRegion)(command['config']['functions'], region)).toEqual({
+                'us-east-1': [
+                    'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                    'arn:aws:lambda:us-east-1:123456789012:function:another',
+                ],
+                'us-east-2': ['arn:aws:lambda:us-east-2:123456789012:function:third-func'],
+            });
+        });
+        test('uses default region for functions not in arn format', () => {
+            process.env = {};
+            const command = (0, fixtures_1.createCommand)(instrument_1.InstrumentCommand);
+            command['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:*:123456789012:function:func-with-wildcard',
+                'func-without-region',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            command['region'] = 'ap-south-1';
+            expect((0, commons_1.collectFunctionsByRegion)(command['functions'], command['region'])).toEqual({
+                'ap-south-1': ['arn:aws:lambda:*:123456789012:function:func-with-wildcard', 'func-without-region'],
+                'us-east-1': ['arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world'],
+                'us-east-2': ['arn:aws:lambda:us-east-2:123456789012:function:third-func'],
+            });
+        });
+        test('fails to collect when there are regionless functions and no default region is set', () => {
+            process.env = {};
+            const command = (0, fixtures_1.createCommand)(instrument_1.InstrumentCommand);
+            command['functions'] = [
+                'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world',
+                'arn:aws:lambda:*:123456789012:function:func-with-wildcard',
+                'func-without-region',
+                'arn:aws:lambda:us-east-2:123456789012:function:third-func',
+            ];
+            command['region'] = undefined;
+            command['config']['region'] = undefined;
+            let functionsGroup;
+            try {
+                functionsGroup = (0, commons_1.collectFunctionsByRegion)(command['functions'], command['region']);
+            }
+            catch (err) {
+                // Do nothing
+            }
+            expect(functionsGroup).toBeUndefined();
+        });
+    });
+    describe('findLatestLayerVersion', () => {
+        beforeEach(() => {
+            lambdaClientMock.reset();
+            (0, fixtures_2.mockLambdaClientCommands)(lambdaClientMock);
+        });
+        test('finds latests version for Python39', () => __awaiter(void 0, void 0, void 0, function* () {
+            const layer = `arn:aws:lambda:sa-east-1:${constants_2.DEFAULT_LAYER_AWS_ACCOUNT}:layer:Datadog-Python39`;
+            (0, fixtures_2.mockLambdaLayers)(lambdaClientMock, {
+                [`${layer}:1`]: {
+                    LayerName: layer,
+                    VersionNumber: 1,
+                },
+                [`${layer}:2`]: {
+                    LayerName: layer,
+                    VersionNumber: 2,
+                },
+                [`${layer}:10`]: {
+                    LayerName: layer,
+                    VersionNumber: 10,
+                },
+                [`${layer}:20`]: {
+                    LayerName: layer,
+                    VersionNumber: 20,
+                },
+                [`${layer}:30`]: {
+                    LayerName: layer,
+                    VersionNumber: 30,
+                },
+                [`${layer}:31`]: {
+                    LayerName: layer,
+                    VersionNumber: 31,
+                },
+                [`${layer}:32`]: {
+                    LayerName: layer,
+                    VersionNumber: 32,
+                },
+            });
+            const runtime = 'python3.9';
+            const region = 'sa-east-1';
+            const expectedLatestVersion = 32;
+            const latestVersionFound = yield (0, commons_1.findLatestLayerVersion)(runtime, region);
+            expect(latestVersionFound).toBe(expectedLatestVersion);
+        }));
+        test('finds latests version for Node20', () => __awaiter(void 0, void 0, void 0, function* () {
+            const layer = `arn:aws:lambda:us-east-1:${constants_2.DEFAULT_LAYER_AWS_ACCOUNT}:layer:Datadog-Node20-x`;
+            (0, fixtures_2.mockLambdaLayers)(lambdaClientMock, {
+                [`${layer}:1`]: {
+                    LayerName: layer,
+                    VersionNumber: 1,
+                },
+                [`${layer}:2`]: {
+                    LayerName: layer,
+                    VersionNumber: 2,
+                },
+                [`${layer}:10`]: {
+                    LayerName: layer,
+                    VersionNumber: 10,
+                },
+                [`${layer}:20`]: {
+                    LayerName: layer,
+                    VersionNumber: 20,
+                },
+                [`${layer}:30`]: {
+                    LayerName: layer,
+                    VersionNumber: 30,
+                },
+                [`${layer}:40`]: {
+                    LayerName: layer,
+                    VersionNumber: 40,
+                },
+                [`${layer}:41`]: {
+                    LayerName: layer,
+                    VersionNumber: 41,
+                },
+            });
+            const runtime = 'nodejs20.x';
+            const region = 'us-east-1';
+            const expectedLatestVersion = 41;
+            const latestVersionFound = yield (0, commons_1.findLatestLayerVersion)(runtime, region);
+            expect(latestVersionFound).toBe(expectedLatestVersion);
+        }));
+        test('returns 0 when no layer can be found', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = 'python3.12';
+            const region = 'us-east-1';
+            const expectedLatestVersion = 0;
+            const latestVersionFound = yield (0, commons_1.findLatestLayerVersion)(runtime, region);
+            expect(latestVersionFound).toBe(expectedLatestVersion);
+        }));
+    });
+    describe('getAWSCredentials', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterEach(() => {
+            process.env = OLD_ENV;
+        });
+        fs.readFile.mockImplementation((a, b, callback) => callback({ code: 'ENOENT' }));
+        test('returns credentials when `fromNodeProviderChain` returns a succesful promise', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            credential_providers_1.fromNodeProviderChain.mockImplementation(() => () => Promise.resolve({
+                accessKeyId: fixtures_2.mockAwsAccessKeyId,
+                secretAccessKey: fixtures_2.mockAwsSecretAccessKey,
+            }));
+            const credentials = yield (0, commons_1.getAWSCredentials)();
+            expect(credentials).toStrictEqual({
+                accessKeyId: fixtures_2.mockAwsAccessKeyId,
+                secretAccessKey: fixtures_2.mockAwsSecretAccessKey,
+            });
+        }));
+        test('throws an error when `fromNodeProviderChain` fails when fetching credentials', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            credential_providers_1.fromNodeProviderChain.mockImplementation(() => () => Promise.reject(new Error('Unexpected error')));
+            let error;
+            try {
+                yield (0, commons_1.getAWSCredentials)();
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    error = e;
+                }
+            }
+            expect(error === null || error === void 0 ? void 0 : error.message).toBe("Couldn't fetch AWS credentials. Unexpected error");
+        }));
+    });
+    describe('isMissingDatadogEnvVars', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('returns true when any Datadog Env Var is missing', () => {
+            process.env[constants_1.CI_SITE_ENV_VAR] = 'datadoghq.com';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(true);
+            // Reset env
+            process.env = {};
+            process.env[constants_1.CI_API_KEY_ENV_VAR] = 'SOME-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(true);
+            process.env = {};
+            process.env[constants_1.API_KEY_ENV_VAR] = 'SOME-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(true);
+            process.env = {};
+            process.env[constants_2.CI_KMS_API_KEY_ENV_VAR] = 'SOME-AWS-KMS-API-KEY-CONTAINING-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(true);
+            process.env = {};
+            process.env[constants_2.CI_API_KEY_SECRET_ARN_ENV_VAR] = 'SOME-AWS-SECRET-ARN-CONTAINING-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(true);
+        });
+        test('returns false when Datadog Env Vars are set with DATADOG_API_KEY', () => {
+            process.env[constants_1.CI_API_KEY_ENV_VAR] = 'SOME-DATADOG-API-KEY';
+            process.env[constants_1.CI_SITE_ENV_VAR] = 'datadoghq.com';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(false);
+        });
+        test('returns false when Datadog Env Vars are set with DD_API_KEY', () => {
+            process.env[constants_1.API_KEY_ENV_VAR] = 'SOME-DATADOG-API-KEY';
+            process.env[constants_1.CI_SITE_ENV_VAR] = 'datadoghq.com';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(false);
+        });
+        test('returns false when Datadog Env Vars are set with DATADOG_KMS_API_KEY', () => {
+            process.env[constants_2.CI_KMS_API_KEY_ENV_VAR] = 'SOME-AWS-KMS-API-KEY-CONTAINING-DATADOG-API-KEY';
+            process.env[constants_1.CI_SITE_ENV_VAR] = 'datadoghq.com';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(false);
+        });
+        test('returns false when Datadog Env Vars are set with DATADOG_API_KEY_SECRET_ARN', () => {
+            process.env[constants_2.CI_API_KEY_SECRET_ARN_ENV_VAR] = 'SOME-AWS-SECRET-ARN-CONTAINING-DATADOG-API-KEY';
+            process.env[constants_1.CI_SITE_ENV_VAR] = 'datadoghq.com';
+            expect((0, commons_1.isMissingDatadogEnvVars)()).toBe(false);
+        });
+    });
+    describe('isMissingAnyDatadogApiKeyEnvVar', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('returns true when no Datadog Api Key is set', () => {
+            expect((0, commons_1.isMissingAnyDatadogApiKeyEnvVar)()).toBe(true);
+        });
+        test('returns false when DATADOG_API_KEY is set', () => {
+            process.env[constants_1.CI_API_KEY_ENV_VAR] = 'SOME-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingAnyDatadogApiKeyEnvVar)()).toBe(false);
+        });
+        test('returns false when DD_API_KEY is set', () => {
+            process.env[constants_1.API_KEY_ENV_VAR] = 'SOME-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingAnyDatadogApiKeyEnvVar)()).toBe(false);
+        });
+        test('returns false when DATADOG_KMS_API_KEY is set', () => {
+            process.env[constants_2.CI_KMS_API_KEY_ENV_VAR] = 'SOME-AWS-KMS-API-KEY-CONTAINING-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingAnyDatadogApiKeyEnvVar)()).toBe(false);
+        });
+        test('returns false when DATADOG_API_KEY_SECRET_ARN is set', () => {
+            process.env[constants_2.CI_API_KEY_SECRET_ARN_ENV_VAR] = 'SOME-AWS-SECRET-ARN-CONTAINING-DATADOG-API-KEY';
+            expect((0, commons_1.isMissingAnyDatadogApiKeyEnvVar)()).toBe(false);
+        });
+    });
+    describe('getLayerArn', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('gets sa-east-1 Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = (0, commons_1.getLayerArn)({}, constants_2.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_2.mockAwsAccount}:layer:Datadog-Extension`);
+        }));
+        test('gets sa-east-1 arm64 Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = {
+                Architectures: [client_lambda_1.Architecture.arm64],
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, constants_2.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_2.mockAwsAccount}:layer:Datadog-Extension-ARM`);
+        }));
+        test('gets us-gov-1 gov cloud Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = (0, commons_1.getLayerArn)({}, constants_2.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_2.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Extension`);
+        }));
+        test('gets us-gov-1 gov cloud arm64 Lambda Extension layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = {
+                Architectures: [client_lambda_1.Architecture.arm64],
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, constants_2.EXTENSION_LAYER_KEY, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_2.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Extension-ARM`);
+        }));
+        test('gets sa-east-1 Node20 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = client_lambda_1.Runtime.nodejs20x;
+            const config = {
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_2.mockAwsAccount}:layer:Datadog-Node20-x`);
+        }));
+        test('gets sa-east-1 Python39 arm64 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = client_lambda_1.Runtime.python39;
+            const config = {
+                Architectures: [client_lambda_1.Architecture.arm64],
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'sa-east-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_2.mockAwsAccount}:layer:Datadog-Python39-ARM`);
+        }));
+        test('gets us-gov-1 Python312 gov cloud Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = client_lambda_1.Runtime.python312;
+            const config = {
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_2.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Python312`);
+        }));
+        test('gets us-gov-1 Python39 gov cloud arm64 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = client_lambda_1.Runtime.python39;
+            const config = {
+                Architectures: [client_lambda_1.Architecture.arm64],
+                Runtime: runtime,
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-gov-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws-us-gov:lambda:${region}:${constants_2.GOVCLOUD_LAYER_AWS_ACCOUNT}:layer:Datadog-Python39-ARM`);
+        }));
+        test('gets dotnet6 arm64 Lambda Library layer ARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runtime = client_lambda_1.Runtime.dotnet6;
+            const config = {
+                Runtime: runtime,
+                Architectures: [client_lambda_1.Architecture.arm64],
+            };
+            const settings = {
+                flushMetricsToLogs: false,
+                layerAWSAccount: fixtures_2.mockAwsAccount,
+                mergeXrayTraces: false,
+                tracingEnabled: false,
+            };
+            const region = 'us-east-1';
+            const layerArn = (0, commons_1.getLayerArn)(config, config.Runtime, region, settings);
+            expect(layerArn).toEqual(`arn:aws:lambda:${region}:${fixtures_2.mockAwsAccount}:layer:dd-trace-dotnet-ARM`);
+        }));
+    });
+    describe('getLayerNameWithVersion', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('returns the correct name and version given an extension layer arn', () => {
+            const layerName = constants_2.DD_LAMBDA_EXTENSION_LAYER_NAME;
+            const version = '16';
+            const layerNameWithVersion = `${layerName}:${version}`;
+            const layerArn = `arn:aws:lambda:sa-east-1:${fixtures_2.mockAwsAccount}:layer:${layerNameWithVersion}`;
+            expect((0, commons_1.getLayerNameWithVersion)(layerArn)).toBe(layerNameWithVersion);
+        });
+        test('returns the correct name and version given a library layer arn', () => {
+            const layerName = 'Datadog-Python39';
+            const version = '59';
+            const layerNameWithVersion = `${layerName}:${version}`;
+            const layerArn = `arn:aws:lambda:sa-east-1:${fixtures_2.mockAwsAccount}:layer:${layerNameWithVersion}`;
+            expect((0, commons_1.getLayerNameWithVersion)(layerArn)).toBe(layerNameWithVersion);
+        });
+        test('returns undefined if arn is incomplete', () => {
+            const layerArn = `arn:aws:lambda:sa-east-1:${fixtures_2.mockAwsAccount}:layer:Datadog-Python39`;
+            expect((0, commons_1.getLayerNameWithVersion)(layerArn)).toBe(undefined);
+        });
+    });
+    describe('getRegion', () => {
+        test('should return the expected region', () => {
+            const functionARN = 'arn:aws:lambda:us-east-1:123456789012:function:lambda-hello-world';
+            const expectedRegion = 'us-east-1';
+            const region = (0, commons_1.getRegion)(functionARN);
+            expect(region).toBe(expectedRegion);
+        });
+        test('should return undefined if Function ARN does not contain the region', () => {
+            const functionName = 'lambda-hello-world';
+            const region = (0, commons_1.getRegion)(functionName);
+            expect(region).toBe(undefined);
+        });
+    });
+    describe('sentenceMatchesRegEx', () => {
+        const tags = [
+            ['not@complying:regex-should-fail', false],
+            ['1first-char-is-number:should-fail', false],
+            ['_also-not-complying:should-fail', false],
+            ['complying_tag:accepted/with/slashes.and.dots,but-empty-tag', false],
+            ['also_complying:success,1but_is_illegal:should-fail', false],
+            ['this:complies,also_this_one:yes,numb3r_in_name:should-succeed,dots:al.lo.wed', true],
+            ['complying_ip_address_4:192.342.3134.231', true],
+            ['complying:alone', true],
+            ['one_divided_by_two:1/2,one_divided_by_four:0.25,three_minus_one_half:3-1/2', true],
+            ['this_is_a_valid_t4g:yes/it.is-42', true],
+            // multiple colons, periods in tag, slashes in tag
+            ['env-staging:east:staging,version.minor:1,version.major:3.4/v3,category/service:not/defined', true],
+            ['email:user@email.com,numb3r:t', true],
+        ];
+        test.each(tags)('check if the tags match the expected result from the regex', (tag, expectedResult) => {
+            const result = !!(0, commons_1.sentenceMatchesRegEx)(tag, constants_2.EXTRA_TAGS_REG_EXP);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('updateLambdaFunctionConfig', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            cloudWatchLogsClientMock.reset();
+            lambdaClientMock.reset();
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('updates every lambda', () => __awaiter(void 0, void 0, void 0, function* () {
+            const configs = [
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                        Handler: 'index.handler',
+                        Runtime: client_lambda_1.Runtime.nodejs20x,
+                    },
+                    lambdaLibraryLayerArn: 'arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x',
+                    updateFunctionConfigurationCommandInput: {
+                        Environment: {
+                            Variables: {
+                                [constants_2.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                                [constants_2.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                                [constants_2.TRACE_ENABLED_ENV_VAR]: 'false',
+                            },
+                        },
+                        FunctionName: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                        Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                        Layers: ['arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x:22'],
+                    },
+                },
+            ];
+            yield Promise.all(configs.map((config) => __awaiter(void 0, void 0, void 0, function* () { return (0, commons_1.updateLambdaFunctionConfig)(lambdaClientMock, cloudWatchLogsClientMock, config); })));
+            expect(lambdaClientMock).toHaveReceivedCommandWith(client_lambda_1.UpdateFunctionConfigurationCommand, {
+                Environment: {
+                    Variables: {
+                        [constants_2.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                        [constants_2.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                        [constants_2.TRACE_ENABLED_ENV_VAR]: 'false',
+                    },
+                },
+                FunctionName: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                Layers: ['arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x:22'],
+            });
+        }));
+    });
+    describe('handleLambdaFunctionUpdates', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            cloudWatchLogsClientMock.reset();
+            lambdaClientMock.reset();
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        const stdout = { write: (_) => jest.fn() };
+        const getConfigs = (lambdaClient) => [
+            {
+                lambdaClient,
+                cloudWatchLogsClientMock,
+                configs: [
+                    {
+                        functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                        lambdaConfig: {
+                            FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                            Handler: 'index.handler',
+                            Runtime: 'nodejs20.x',
+                        },
+                        lambdaLibraryLayerArn: 'arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x',
+                        updateFunctionConfigurationCommandInput: {
+                            Environment: {
+                                Variables: {
+                                    [constants_2.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                                    [constants_2.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                                    [constants_2.TRACE_ENABLED_ENV_VAR]: 'false',
+                                },
+                            },
+                            FunctionName: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+                            Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                            Layers: ['arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x:XX'],
+                        },
+                    },
+                ],
+                region: 'us-east-1',
+            },
+            {
+                lambdaClient,
+                cloudWatchLogsClientMock,
+                configs: [
+                    {
+                        functionARN: 'arn:aws:lambda:us-east-2:000000000000:function:autoinstrument',
+                        lambdaConfig: {
+                            FunctionArn: 'arn:aws:lambda:us-east-2:000000000000:function:autoinstrument',
+                            Handler: 'index.handler',
+                            Runtime: 'nodejs20.x',
+                        },
+                        lambdaLibraryLayerArn: 'arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x',
+                        updateFunctionConfigurationCommandInput: {
+                            Environment: {
+                                Variables: {
+                                    [constants_2.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                                    [constants_2.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                                    [constants_2.TRACE_ENABLED_ENV_VAR]: 'false',
+                                },
+                            },
+                            FunctionName: 'arn:aws:lambda:us-east-2:000000000000:function:autoinstrument',
+                            Handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+                            Layers: ['arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node20-x:XX'],
+                        },
+                    },
+                ],
+                region: 'us-east-2',
+            },
+        ];
+        test('throws an error when all functions from every region fail to update', () => __awaiter(void 0, void 0, void 0, function* () {
+            lambdaClientMock.on(client_lambda_1.UpdateFunctionConfigurationCommand).rejects();
+            const configs = getConfigs(lambdaClientMock);
+            yield expect((0, commons_1.handleLambdaFunctionUpdates)(configs, stdout)).rejects.toThrow();
+        }));
+        test('to not throw an error when at least one function is updated', () => __awaiter(void 0, void 0, void 0, function* () {
+            lambdaClientMock
+                .on(client_lambda_1.UpdateFunctionConfigurationCommand, {
+                FunctionName: 'arn:aws:lambda:us-east-1:000000000000:function:autoinstrument',
+            })
+                .rejects();
+            const configs = getConfigs(lambdaClientMock);
+            // when sucessful, the function doesnt do anything
+            const result = yield (0, commons_1.handleLambdaFunctionUpdates)(configs, stdout);
+            expect(result).toBe(undefined);
+        }));
+    });
+    describe('handles multiple runtimes', () => {
+        test('returns true if all runtimes are uniform', () => __awaiter(void 0, void 0, void 0, function* () {
+            const configs = [
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:func3',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:func3',
+                        Handler: 'index.handler',
+                        Runtime: 'nodejs16.x',
+                    },
+                },
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:func4',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:func4',
+                        Handler: 'index.handler',
+                        Runtime: 'nodejs18.x',
+                    },
+                },
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:func5',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:func5',
+                        Handler: 'index.handler',
+                        Runtime: 'nodejs20.x',
+                    },
+                },
+            ];
+            expect((0, commons_1.checkRuntimeTypesAreUniform)(configs)).toBe(true);
+        }));
+        test('returns false if runtimes are not uniform', () => __awaiter(void 0, void 0, void 0, function* () {
+            const configs = [
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:func1',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:func1',
+                        Handler: 'index.handler',
+                        Runtime: 'nodejs20.x',
+                    },
+                },
+                {
+                    functionARN: 'arn:aws:lambda:us-east-1:000000000000:function:func2',
+                    lambdaConfig: {
+                        FunctionArn: 'arn:aws:lambda:us-east-1:000000000000:function:func2',
+                        Handler: 'index.handler',
+                        Runtime: 'python3.9',
+                    },
+                },
+            ];
+            expect((0, commons_1.checkRuntimeTypesAreUniform)(configs)).toBe(false);
+        }));
+    });
+    describe('maskConfig', () => {
+        it('should mask a Lambda config correctly', () => {
+            const maskedConfig = (0, commons_1.maskConfig)(fixtures_2.MOCK_LAMBDA_CONFIG);
+            expect(maskedConfig).toMatchSnapshot();
+        });
+        it('should not modify config if env vars are missing', () => {
+            const lambdaConfigCopy = JSON.parse(JSON.stringify(fixtures_2.MOCK_LAMBDA_CONFIG));
+            delete lambdaConfigCopy.Environment.Variables;
+            const maskedConfig = (0, commons_1.maskConfig)(lambdaConfigCopy);
+            expect(maskedConfig).toMatchSnapshot();
+        });
+    });
+});
+//# sourceMappingURL=commons.test.js.map