aws-cdk 2.8.0 → 2.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aws-cdk",
   "description": "CDK Toolkit, the command line tool for CDK apps",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "bin": {
     "cdk": "bin/cdk"
   },
@@ -35,7 +35,7 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@aws-cdk/core": "2.8.0",
+    "@aws-cdk/core": "2.9.0",
     "@octokit/rest": "^18.12.0",
     "@types/archiver": "^5.3.1",
     "@types/fs-extra": "^8.1.2",
@@ -52,29 +52,29 @@
     "@types/wrap-ansi": "^3.0.0",
     "@types/yargs": "^15.0.14",
     "aws-sdk-mock": "^5.5.1",
-    "@aws-cdk/cdk-build-tools": "2.8.0",
+    "@aws-cdk/cdk-build-tools": "2.9.0",
     "constructs": "^10.0.0",
     "jest": "^27.4.7",
     "make-runnable": "^1.3.10",
     "mockery": "^2.1.0",
     "nock": "^13.2.2",
-    "@aws-cdk/pkglint": "2.8.0",
+    "@aws-cdk/pkglint": "2.9.0",
     "sinon": "^9.2.4",
-    "ts-jest": "^27.1.2",
+    "ts-jest": "^27.1.3",
     "ts-mock-imports": "^1.3.8",
     "xml-js": "^1.6.11"
   },
   "dependencies": {
-    "@aws-cdk/cloud-assembly-schema": "2.8.0",
-    "@aws-cdk/cloudformation-diff": "2.8.0",
-    "@aws-cdk/cx-api": "2.8.0",
-    "@aws-cdk/region-info": "2.8.0",
+    "@aws-cdk/cloud-assembly-schema": "2.9.0",
+    "@aws-cdk/cloudformation-diff": "2.9.0",
+    "@aws-cdk/cx-api": "2.9.0",
+    "@aws-cdk/region-info": "2.9.0",
     "@jsii/check-node": "1.52.1",
     "archiver": "^5.3.0",
     "aws-sdk": "^2.979.0",
     "camelcase": "^6.3.0",
-    "cdk-assets": "2.8.0",
-    "chokidar": "^3.5.2",
+    "cdk-assets": "2.9.0",
+    "chokidar": "^3.5.3",
     "chalk": "^4",
     "decamelize": "^5.0.1",
     "fs-extra": "^9.1.0",

package/test/api/hotswap/lambda-functions-docker-hotswap-deployments.test.d.ts

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

package/test/api/hotswap/lambda-functions-docker-hotswap-deployments.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const setup = require("./hotswap-test-setup");
+let mockUpdateLambdaCode;
+let mockTagResource;
+let mockUntagResource;
+let hotswapMockSdkProvider;
+beforeEach(() => {
+    hotswapMockSdkProvider = setup.setupHotswapTests();
+    mockUpdateLambdaCode = jest.fn();
+    mockTagResource = jest.fn();
+    mockUntagResource = jest.fn();
+    hotswapMockSdkProvider.stubLambda({
+        updateFunctionCode: mockUpdateLambdaCode,
+        tagResource: mockTagResource,
+        untagResource: mockUntagResource,
+    });
+});
+test('calls the updateLambdaCode() API when it receives only a code difference in a Lambda function', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            Func: {
+                Type: 'AWS::Lambda::Function',
+                Properties: {
+                    Code: {
+                        ImageUri: 'current-image',
+                    },
+                    FunctionName: 'my-function',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                Func: {
+                    Type: 'AWS::Lambda::Function',
+                    Properties: {
+                        Code: {
+                            ImageUri: 'new-image',
+                        },
+                        FunctionName: 'my-function',
+                    },
+                    Metadata: {
+                        'aws:asset:path': 'new-path',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).not.toBeUndefined();
+    expect(mockUpdateLambdaCode).toHaveBeenCalledWith({
+        FunctionName: 'my-function',
+        ImageUri: 'new-image',
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/test/api/hotswap/lambda-functions-inline-hotswap-deployments.test.d.ts

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

package/test/api/hotswap/lambda-functions-inline-hotswap-deployments.test.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const setup = require("./hotswap-test-setup");
+let mockUpdateLambdaCode;
+let mockTagResource;
+let mockUntagResource;
+let hotswapMockSdkProvider;
+beforeEach(() => {
+    hotswapMockSdkProvider = setup.setupHotswapTests();
+    mockUpdateLambdaCode = jest.fn();
+    mockTagResource = jest.fn();
+    mockUntagResource = jest.fn();
+    hotswapMockSdkProvider.stubLambda({
+        updateFunctionCode: mockUpdateLambdaCode,
+        tagResource: mockTagResource,
+        untagResource: mockUntagResource,
+    });
+});
+test('calls the updateLambdaCode() API when it receives only a code difference in a Lambda function (Inline Node.js code)', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            Func: {
+                Type: 'AWS::Lambda::Function',
+                Properties: {
+                    Code: {
+                        ZipFile: 'exports.handler = () => {return true}',
+                    },
+                    Runtime: 'nodejs14.x',
+                    FunctionName: 'my-function',
+                },
+            },
+        },
+    });
+    const newCode = 'exports.handler = () => {return false}';
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                Func: {
+                    Type: 'AWS::Lambda::Function',
+                    Properties: {
+                        Code: {
+                            ZipFile: newCode,
+                        },
+                        Runtime: 'nodejs14.x',
+                        FunctionName: 'my-function',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).not.toBeUndefined();
+    expect(mockUpdateLambdaCode).toHaveBeenCalledWith({
+        FunctionName: 'my-function',
+        ZipFile: expect.any(Buffer),
+    });
+});
+test('calls the updateLambdaCode() API when it receives only a code difference in a Lambda function (Inline Python code)', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            Func: {
+                Type: 'AWS::Lambda::Function',
+                Properties: {
+                    Code: {
+                        ZipFile: 'def handler(event, context):\n  return True',
+                    },
+                    Runtime: 'python3.9',
+                    FunctionName: 'my-function',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                Func: {
+                    Type: 'AWS::Lambda::Function',
+                    Properties: {
+                        Code: {
+                            ZipFile: 'def handler(event, context):\n  return False',
+                        },
+                        Runtime: 'python3.9',
+                        FunctionName: 'my-function',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).not.toBeUndefined();
+    expect(mockUpdateLambdaCode).toHaveBeenCalledWith({
+        FunctionName: 'my-function',
+        ZipFile: expect.any(Buffer),
+    });
+});
+test('throw a CfnEvaluationException when it receives an unsupported function runtime', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            Func: {
+                Type: 'AWS::Lambda::Function',
+                Properties: {
+                    Code: {
+                        ZipFile: 'def handler(event:, context:) true end',
+                    },
+                    Runtime: 'ruby2.7',
+                    FunctionName: 'my-function',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                Func: {
+                    Type: 'AWS::Lambda::Function',
+                    Properties: {
+                        Code: {
+                            ZipFile: 'def handler(event:, context:) false end',
+                        },
+                        Runtime: 'ruby2.7',
+                        FunctionName: 'my-function',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const tryHotswap = hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    await expect(tryHotswap).rejects.toThrow('runtime ruby2.7 is unsupported, only node.js and python runtimes are currently supported.');
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-functions-inline-hotswap-deployments.test.js","sourceRoot":"","sources":["lambda-functions-inline-hotswap-deployments.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Lambda } from 'aws-sdk';\nimport * as setup from './hotswap-test-setup';\n\nlet mockUpdateLambdaCode: (params: Lambda.Types.UpdateFunctionCodeRequest) => Lambda.Types.FunctionConfiguration;\nlet mockTagResource: (params: Lambda.Types.TagResourceRequest) => {};\nlet mockUntagResource: (params: Lambda.Types.UntagResourceRequest) => {};\nlet hotswapMockSdkProvider: setup.HotswapMockSdkProvider;\n\nbeforeEach(() => {\n  hotswapMockSdkProvider = setup.setupHotswapTests();\n  mockUpdateLambdaCode = jest.fn();\n  mockTagResource = jest.fn();\n  mockUntagResource = jest.fn();\n  hotswapMockSdkProvider.stubLambda({\n    updateFunctionCode: mockUpdateLambdaCode,\n    tagResource: mockTagResource,\n    untagResource: mockUntagResource,\n  });\n});\n\ntest('calls the updateLambdaCode() API when it receives only a code difference in a Lambda function (Inline Node.js code)', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            ZipFile: 'exports.handler = () => {return true}',\n          },\n          Runtime: 'nodejs14.x',\n          FunctionName: 'my-function',\n        },\n      },\n    },\n  });\n  const newCode = 'exports.handler = () => {return false}';\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        Func: {\n          Type: 'AWS::Lambda::Function',\n          Properties: {\n            Code: {\n              ZipFile: newCode,\n            },\n            Runtime: 'nodejs14.x',\n            FunctionName: 'my-function',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).not.toBeUndefined();\n  expect(mockUpdateLambdaCode).toHaveBeenCalledWith({\n    FunctionName: 'my-function',\n    ZipFile: expect.any(Buffer),\n  });\n});\n\ntest('calls the updateLambdaCode() API when it receives only a code difference in a Lambda function (Inline Python code)', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            ZipFile: 'def handler(event, context):\\n  return True',\n          },\n          Runtime: 'python3.9',\n          FunctionName: 'my-function',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        Func: {\n          Type: 'AWS::Lambda::Function',\n          Properties: {\n            Code: {\n              ZipFile: 'def handler(event, context):\\n  return False',\n            },\n            Runtime: 'python3.9',\n            FunctionName: 'my-function',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).not.toBeUndefined();\n  expect(mockUpdateLambdaCode).toHaveBeenCalledWith({\n    FunctionName: 'my-function',\n    ZipFile: expect.any(Buffer),\n  });\n});\n\ntest('throw a CfnEvaluationException when it receives an unsupported function runtime', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            ZipFile: 'def handler(event:, context:) true end',\n          },\n          Runtime: 'ruby2.7',\n          FunctionName: 'my-function',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        Func: {\n          Type: 'AWS::Lambda::Function',\n          Properties: {\n            Code: {\n              ZipFile: 'def handler(event:, context:) false end',\n            },\n            Runtime: 'ruby2.7',\n            FunctionName: 'my-function',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const tryHotswap = hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  await expect(tryHotswap).rejects.toThrow('runtime ruby2.7 is unsupported, only node.js and python runtimes are currently supported.');\n});\n"]}

package/test/api/logs/logs-monitor.test.js

@@ -44,7 +44,7 @@ test('continue to the next page if it exists', async () => {
     // THEN
     expect(stderrMock).toHaveBeenCalledTimes(2);
     expect(stderrMock.mock.calls[0][0]).toContain(`[${chalk_1.blue('loggroup')}] ${chalk_1.yellow(HUMAN_TIME)} message`);
-    expect(stderrMock.mock.calls[1][0]).toContain(`[${chalk_1.blue('loggroup')}] ${chalk_1.yellow(new Date(T100).toLocaleTimeString())} (...messages supressed...)`);
+    expect(stderrMock.mock.calls[1][0]).toContain(`[${chalk_1.blue('loggroup')}] ${chalk_1.yellow(new Date(T100).toLocaleTimeString())} >>> \`watch\` shows only the first 100 log messages - the rest have been truncated...`);
 });
 const T0 = 1597837230504;
 const T100 = T0 + 100 * 1000;
@@ -56,4 +56,4 @@ function event(nr, message) {
         ingestionTime: new Date(T0 * nr * 1000).getTime(),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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