@datadog/datadog-ci 0.17.8 → 0.17.9

package/dist/commands/lambda/__tests__/fixtures.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="jest" />
+import { CloudWatchLogs, Lambda } from 'aws-sdk';
+import { Cli, Command } from 'clipanion/lib/advanced';
+export declare const createMockContext: () => {
+    stdout: {
+        toString: () => string;
+        write: (input: string) => void;
+    };
+};
+export declare const makeCli: () => Cli<import("clipanion/lib/advanced").BaseContext>;
+/**
+ * Allow for constructors with any amount of parameters.
+ * Mainly used for testing when we are creating commands.
+ */
+export declare type ConstructorOf<T> = new (...args: any[]) => T;
+/**
+ * Allows to create an instance of any command that
+ * extends the Command clss.
+ *
+ * @param commandClass any class that extends the Command class.
+ * @param parameters parameters to use while creating the commandClass
+ * @returns the instance of the given command with a mock context attatched.
+ */
+export declare const createCommand: <T extends Command<import("clipanion/lib/advanced").BaseContext>>(commandClass: ConstructorOf<T>, ...parameters: any[]) => T;
+export declare const makeMockLambda: (functionConfigs: Record<string, Lambda.FunctionConfiguration>) => {
+    getFunction: jest.Mock<any, any>;
+    listFunctions: jest.Mock<any, any>;
+    listTags: jest.Mock<any, any>;
+    tagResource: jest.Mock<any, any>;
+    updateFunctionConfiguration: jest.Mock<any, any>;
+};
+export declare const makeMockCloudWatchLogs: (logGroups: Record<string, {
+    config: CloudWatchLogs.DescribeLogGroupsResponse;
+    filters?: CloudWatchLogs.DescribeSubscriptionFiltersResponse;
+}>) => {
+    createLogGroup: jest.Mock<any, any>;
+    deleteSubscriptionFilter: jest.Mock<any, any>;
+    describeLogGroups: jest.Mock<any, any>;
+    describeSubscriptionFilters: jest.Mock<any, any>;
+    putSubscriptionFilter: jest.Mock<any, any>;
+};
+export declare const mockAwsAccount = "123456789012";

package/dist/commands/lambda/__tests__/fixtures.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockAwsAccount = exports.makeMockCloudWatchLogs = exports.makeMockLambda = exports.createCommand = exports.makeCli = exports.createMockContext = void 0;
+const advanced_1 = require("clipanion/lib/advanced");
+const instrument_1 = require("../instrument");
+const uninstrument_1 = require("../uninstrument");
+const createMockContext = () => {
+    let data = '';
+    return {
+        stdout: {
+            toString: () => data,
+            write: (input) => {
+                data += input;
+            },
+        },
+    };
+};
+exports.createMockContext = createMockContext;
+const makeCli = () => {
+    const cli = new advanced_1.Cli();
+    cli.register(instrument_1.InstrumentCommand);
+    cli.register(uninstrument_1.UninstrumentCommand);
+    return cli;
+};
+exports.makeCli = makeCli;
+/**
+ * Allows to create an instance of any command that
+ * extends the Command clss.
+ *
+ * @param commandClass any class that extends the Command class.
+ * @param parameters parameters to use while creating the commandClass
+ * @returns the instance of the given command with a mock context attatched.
+ */
+const createCommand = (commandClass, ...parameters) => {
+    // Create a new instance of commandClass and pass in the parameters
+    const command = new commandClass(...parameters);
+    command.context = exports.createMockContext();
+    return command;
+};
+exports.createCommand = createCommand;
+const makeMockLambda = (functionConfigs) => ({
+    getFunction: jest.fn().mockImplementation(({ FunctionName }) => ({
+        promise: () => Promise.resolve({ Configuration: functionConfigs[FunctionName] }),
+    })),
+    listFunctions: jest.fn().mockImplementation(() => ({
+        promise: () => Promise.resolve({ Functions: Object.values(functionConfigs) }),
+    })),
+    listTags: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve({ Tags: {} }) })),
+    tagResource: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+    updateFunctionConfiguration: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+});
+exports.makeMockLambda = makeMockLambda;
+const makeMockCloudWatchLogs = (logGroups) => ({
+    createLogGroup: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+    deleteSubscriptionFilter: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+    describeLogGroups: jest.fn().mockImplementation(({ logGroupNamePrefix }) => {
+        var _a, _b;
+        const groups = (_b = (_a = logGroups[logGroupNamePrefix]) === null || _a === void 0 ? void 0 : _a.config) !== null && _b !== void 0 ? _b : { logGroups: [] };
+        return {
+            promise: () => Promise.resolve(groups),
+        };
+    }),
+    describeSubscriptionFilters: jest.fn().mockImplementation(({ logGroupName }) => {
+        var _a, _b;
+        const groups = (_b = (_a = logGroups[logGroupName]) === null || _a === void 0 ? void 0 : _a.filters) !== null && _b !== void 0 ? _b : { subscriptionFilters: [] };
+        return {
+            promise: () => Promise.resolve(groups),
+        };
+    }),
+    putSubscriptionFilter: jest.fn().mockImplementation(() => ({ promise: () => Promise.resolve() })),
+});
+exports.makeMockCloudWatchLogs = makeMockCloudWatchLogs;
+exports.mockAwsAccount = '123456789012';

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

@@ -0,0 +1,171 @@
+"use strict";
+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 });
+/* tslint:disable:no-string-literal */
+const constants_1 = require("../../constants");
+const commons_1 = require("../../functions/commons");
+const instrument_1 = require("../../instrument");
+const fixtures_1 = require("../fixtures");
+describe('commons', () => {
+    describe('collectFunctionsByRegion', () => {
+        test('groups functions with region read from arn', () => {
+            process.env = {};
+            const command = 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(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 = 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(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 = 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(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 = 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 = commons_1.collectFunctionsByRegion(command['functions'], command['region']);
+            }
+            catch (err) {
+                // Do nothing
+            }
+            expect(functionsGroup).toBeUndefined();
+        });
+    });
+    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 = 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 = 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],
+        ];
+        test.each(tags)('check if the tags match the expected result from the regex', (tag, expectedResult) => {
+            const result = !!commons_1.sentenceMatchesRegEx(tag, constants_1.EXTRA_TAGS_REG_EXP);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('updateLambdaConfigs', () => {
+        const OLD_ENV = process.env;
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {};
+        });
+        afterAll(() => {
+            process.env = OLD_ENV;
+        });
+        test('updates every lambda', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lambda = fixtures_1.makeMockLambda({});
+            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: 'nodejs12.x',
+                    },
+                    lambdaLibraryLayerArn: 'arn:aws:lambda:us-east-1:464622532012:layer:Datadog-Node12-x',
+                    updateRequest: {
+                        Environment: {
+                            Variables: {
+                                [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                                [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                                [constants_1.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-Node12-x:22'],
+                    },
+                },
+            ];
+            const cloudWatch = fixtures_1.makeMockCloudWatchLogs({});
+            yield commons_1.updateLambdaFunctionConfigs(lambda, cloudWatch, configs);
+            expect(lambda.updateFunctionConfiguration).toHaveBeenCalledWith({
+                Environment: {
+                    Variables: {
+                        [constants_1.LAMBDA_HANDLER_ENV_VAR]: 'index.handler',
+                        [constants_1.MERGE_XRAY_TRACES_ENV_VAR]: 'false',
+                        [constants_1.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-Node12-x:22'],
+            });
+        }));
+    });
+});

package/dist/commands/lambda/__tests__/functions/instrument.test.d.ts

@@ -0,0 +1 @@
+export {};