aws-cdk 2.9.0 → 2.13.0

package/test/api/hotswap/appsync-mapping-templates-hotswap-deployments.test.d.ts

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

package/test/api/hotswap/appsync-mapping-templates-hotswap-deployments.test.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const setup = require("./hotswap-test-setup");
+let hotswapMockSdkProvider;
+let mockUpdateResolver;
+let mockUpdateFunction;
+beforeEach(() => {
+    hotswapMockSdkProvider = setup.setupHotswapTests();
+    mockUpdateResolver = jest.fn();
+    mockUpdateFunction = jest.fn();
+    hotswapMockSdkProvider.stubAppSync({ updateResolver: mockUpdateResolver, updateFunction: mockUpdateFunction });
+});
+test('returns undefined when a new Resolver is added to the Stack', async () => {
+    // GIVEN
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncResolver: {
+                    Type: 'AWS::AppSync::Resolver',
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).toBeUndefined();
+});
+test('calls the updateResolver() API when it receives only a mapping template difference in a Unit Resolver', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncResolver: {
+                Type: 'AWS::AppSync::Resolver',
+                Properties: {
+                    ApiId: 'apiId',
+                    FieldName: 'myField',
+                    TypeName: 'Query',
+                    DataSourceName: 'my-datasource',
+                    Kind: 'UNIT',
+                    RequestMappingTemplate: '## original request template',
+                    ResponseMappingTemplate: '## original response template',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    setup.pushStackResourceSummaries(setup.stackSummaryOf('AppSyncResolver', 'AWS::AppSync::Resolver', 'arn:aws:appsync:us-east-1:111111111111:apis/apiId/types/Query/resolvers/myField'));
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncResolver: {
+                    Type: 'AWS::AppSync::Resolver',
+                    Properties: {
+                        ApiId: 'apiId',
+                        FieldName: 'myField',
+                        TypeName: 'Query',
+                        DataSourceName: 'my-datasource',
+                        Kind: 'UNIT',
+                        RequestMappingTemplate: '## new request template',
+                        ResponseMappingTemplate: '## original response template',
+                    },
+                    Metadata: {
+                        'aws:asset:path': 'new-path',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).not.toBeUndefined();
+    expect(mockUpdateResolver).toHaveBeenCalledWith({
+        apiId: 'apiId',
+        dataSourceName: 'my-datasource',
+        typeName: 'Query',
+        fieldName: 'myField',
+        kind: 'UNIT',
+        requestMappingTemplate: '## new request template',
+        responseMappingTemplate: '## original response template',
+    });
+});
+test('does not call the updateResolver() API when it receives only a mapping template difference in a Pipeline Resolver', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncResolver: {
+                Type: 'AWS::AppSync::Resolver',
+                Properties: {
+                    ApiId: 'apiId',
+                    FieldName: 'myField',
+                    TypeName: 'Query',
+                    DataSourceName: 'my-datasource',
+                    Kind: 'PIPELINE',
+                    PipelineConfig: ['function1'],
+                    RequestMappingTemplate: '## original request template',
+                    ResponseMappingTemplate: '## original response template',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncResolver: {
+                    Type: 'AWS::AppSync::Resolver',
+                    Properties: {
+                        ApiId: 'apiId',
+                        FieldName: 'myField',
+                        TypeName: 'Query',
+                        DataSourceName: 'my-datasource',
+                        Kind: 'PIPELINE',
+                        PipelineConfig: ['function1'],
+                        RequestMappingTemplate: '## new request template',
+                        ResponseMappingTemplate: '## original response template',
+                    },
+                    Metadata: {
+                        'aws:asset:path': 'new-path',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).toBeUndefined();
+    expect(mockUpdateResolver).not.toHaveBeenCalled();
+});
+test('does not call the updateResolver() API when it receives a change that is not a mapping template difference in a Resolver', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncResolver: {
+                Type: 'AWS::AppSync::Resolver',
+                Properties: {
+                    RequestMappingTemplate: '## original template',
+                    FieldName: 'oldField',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncResolver: {
+                    Type: 'AWS::AppSync::Resolver',
+                    Properties: {
+                        RequestMappingTemplate: '## new template',
+                        FieldName: 'newField',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).toBeUndefined();
+    expect(mockUpdateResolver).not.toHaveBeenCalled();
+});
+test('does not call the updateResolver() API when a resource with type that is not AWS::AppSync::Resolver but has the same properties is changed', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncResolver: {
+                Type: 'AWS::AppSync::NotAResolver',
+                Properties: {
+                    RequestMappingTemplate: '## original template',
+                    FieldName: 'oldField',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncResolver: {
+                    Type: 'AWS::AppSync::NotAResolver',
+                    Properties: {
+                        RequestMappingTemplate: '## new template',
+                        FieldName: 'newField',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).toBeUndefined();
+    expect(mockUpdateResolver).not.toHaveBeenCalled();
+});
+test('calls the updateFunction() API when it receives only a mapping template difference in a Function', async () => {
+    // GIVEN
+    const mockListFunctions = jest.fn().mockReturnValue({ functions: [{ name: 'my-function', functionId: 'functionId' }] });
+    hotswapMockSdkProvider.stubAppSync({ listFunctions: mockListFunctions, updateFunction: mockUpdateFunction });
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncFunction: {
+                Type: 'AWS::AppSync::FunctionConfiguration',
+                Properties: {
+                    Name: 'my-function',
+                    ApiId: 'apiId',
+                    DataSourceName: 'my-datasource',
+                    FunctionVersion: '2018-05-29',
+                    RequestMappingTemplate: '## original request template',
+                    ResponseMappingTemplate: '## original response template',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncFunction: {
+                    Type: 'AWS::AppSync::FunctionConfiguration',
+                    Properties: {
+                        Name: 'my-function',
+                        ApiId: 'apiId',
+                        DataSourceName: 'my-datasource',
+                        FunctionVersion: '2018-05-29',
+                        RequestMappingTemplate: '## original request template',
+                        ResponseMappingTemplate: '## new response template',
+                    },
+                    Metadata: {
+                        'aws:asset:path': 'new-path',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).not.toBeUndefined();
+    expect(mockUpdateFunction).toHaveBeenCalledWith({
+        apiId: 'apiId',
+        dataSourceName: 'my-datasource',
+        functionId: 'functionId',
+        functionVersion: '2018-05-29',
+        name: 'my-function',
+        requestMappingTemplate: '## original request template',
+        responseMappingTemplate: '## new response template',
+    });
+});
+test('does not call the updateFunction() API when it receives a change that is not a mapping template difference in a Function', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncFunction: {
+                Type: 'AWS::AppSync::FunctionConfiguration',
+                Properties: {
+                    RequestMappingTemplate: '## original template',
+                    Name: 'my-function',
+                    DataSourceName: 'my-datasource',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncFunction: {
+                    Type: 'AWS::AppSync::FunctionConfiguration',
+                    Properties: {
+                        RequestMappingTemplate: '## new template',
+                        Name: 'my-function',
+                        DataSourceName: 'new-datasource',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).toBeUndefined();
+    expect(mockUpdateFunction).not.toHaveBeenCalled();
+});
+test('does not call the updateFunction() API when a resource with type that is not AWS::AppSync::FunctionConfiguration but has the same properties is changed', async () => {
+    // GIVEN
+    setup.setCurrentCfnStackTemplate({
+        Resources: {
+            AppSyncFunction: {
+                Type: 'AWS::AppSync::NotAFunctionConfiguration',
+                Properties: {
+                    RequestMappingTemplate: '## original template',
+                    Name: 'my-function',
+                    DataSourceName: 'my-datasource',
+                },
+                Metadata: {
+                    'aws:asset:path': 'old-path',
+                },
+            },
+        },
+    });
+    const cdkStackArtifact = setup.cdkStackArtifactOf({
+        template: {
+            Resources: {
+                AppSyncFunction: {
+                    Type: 'AWS::AppSync::NotAFunctionConfiguration',
+                    Properties: {
+                        RequestMappingTemplate: '## new template',
+                        Name: 'my-resolver',
+                        DataSourceName: 'my-datasource',
+                    },
+                },
+            },
+        },
+    });
+    // WHEN
+    const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);
+    // THEN
+    expect(deployStackResult).toBeUndefined();
+    expect(mockUpdateFunction).not.toHaveBeenCalled();
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appsync-mapping-templates-hotswap-deployments.test.js","sourceRoot":"","sources":["appsync-mapping-templates-hotswap-deployments.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { AppSync } from 'aws-sdk';\nimport * as setup from './hotswap-test-setup';\n\nlet hotswapMockSdkProvider: setup.HotswapMockSdkProvider;\nlet mockUpdateResolver: (params: AppSync.UpdateResolverRequest) => AppSync.UpdateResolverResponse;\nlet mockUpdateFunction: (params: AppSync.UpdateFunctionRequest) => AppSync.UpdateFunctionResponse;\n\nbeforeEach(() => {\n  hotswapMockSdkProvider = setup.setupHotswapTests();\n  mockUpdateResolver = jest.fn();\n  mockUpdateFunction = jest.fn();\n  hotswapMockSdkProvider.stubAppSync({ updateResolver: mockUpdateResolver, updateFunction: mockUpdateFunction });\n});\n\ntest('returns undefined when a new Resolver is added to the Stack', async () => {\n  // GIVEN\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncResolver: {\n          Type: 'AWS::AppSync::Resolver',\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n});\n\ntest('calls the updateResolver() API when it receives only a mapping template difference in a Unit Resolver', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncResolver: {\n        Type: 'AWS::AppSync::Resolver',\n        Properties: {\n          ApiId: 'apiId',\n          FieldName: 'myField',\n          TypeName: 'Query',\n          DataSourceName: 'my-datasource',\n          Kind: 'UNIT',\n          RequestMappingTemplate: '## original request template',\n          ResponseMappingTemplate: '## original response template',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  setup.pushStackResourceSummaries(\n    setup.stackSummaryOf(\n      'AppSyncResolver',\n      'AWS::AppSync::Resolver',\n      'arn:aws:appsync:us-east-1:111111111111:apis/apiId/types/Query/resolvers/myField',\n    ),\n  );\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncResolver: {\n          Type: 'AWS::AppSync::Resolver',\n          Properties: {\n            ApiId: 'apiId',\n            FieldName: 'myField',\n            TypeName: 'Query',\n            DataSourceName: 'my-datasource',\n            Kind: 'UNIT',\n            RequestMappingTemplate: '## new request template',\n            ResponseMappingTemplate: '## original response template',\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\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(mockUpdateResolver).toHaveBeenCalledWith({\n    apiId: 'apiId',\n    dataSourceName: 'my-datasource',\n    typeName: 'Query',\n    fieldName: 'myField',\n    kind: 'UNIT',\n    requestMappingTemplate: '## new request template',\n    responseMappingTemplate: '## original response template',\n  });\n});\n\ntest('does not call the updateResolver() API when it receives only a mapping template difference in a Pipeline Resolver', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncResolver: {\n        Type: 'AWS::AppSync::Resolver',\n        Properties: {\n          ApiId: 'apiId',\n          FieldName: 'myField',\n          TypeName: 'Query',\n          DataSourceName: 'my-datasource',\n          Kind: 'PIPELINE',\n          PipelineConfig: ['function1'],\n          RequestMappingTemplate: '## original request template',\n          ResponseMappingTemplate: '## original response template',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncResolver: {\n          Type: 'AWS::AppSync::Resolver',\n          Properties: {\n            ApiId: 'apiId',\n            FieldName: 'myField',\n            TypeName: 'Query',\n            DataSourceName: 'my-datasource',\n            Kind: 'PIPELINE',\n            PipelineConfig: ['function1'],\n            RequestMappingTemplate: '## new request template',\n            ResponseMappingTemplate: '## original response template',\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateResolver).not.toHaveBeenCalled();\n});\n\ntest('does not call the updateResolver() API when it receives a change that is not a mapping template difference in a Resolver', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncResolver: {\n        Type: 'AWS::AppSync::Resolver',\n        Properties: {\n          RequestMappingTemplate: '## original template',\n          FieldName: 'oldField',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncResolver: {\n          Type: 'AWS::AppSync::Resolver',\n          Properties: {\n            RequestMappingTemplate: '## new template',\n            FieldName: 'newField',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateResolver).not.toHaveBeenCalled();\n});\n\ntest('does not call the updateResolver() API when a resource with type that is not AWS::AppSync::Resolver but has the same properties is changed', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncResolver: {\n        Type: 'AWS::AppSync::NotAResolver',\n        Properties: {\n          RequestMappingTemplate: '## original template',\n          FieldName: 'oldField',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncResolver: {\n          Type: 'AWS::AppSync::NotAResolver',\n          Properties: {\n            RequestMappingTemplate: '## new template',\n            FieldName: 'newField',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateResolver).not.toHaveBeenCalled();\n});\n\ntest('calls the updateFunction() API when it receives only a mapping template difference in a Function', async () => {\n  // GIVEN\n  const mockListFunctions = jest.fn().mockReturnValue({ functions: [{ name: 'my-function', functionId: 'functionId' }] });\n  hotswapMockSdkProvider.stubAppSync({ listFunctions: mockListFunctions, updateFunction: mockUpdateFunction });\n\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncFunction: {\n        Type: 'AWS::AppSync::FunctionConfiguration',\n        Properties: {\n          Name: 'my-function',\n          ApiId: 'apiId',\n          DataSourceName: 'my-datasource',\n          FunctionVersion: '2018-05-29',\n          RequestMappingTemplate: '## original request template',\n          ResponseMappingTemplate: '## original response template',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncFunction: {\n          Type: 'AWS::AppSync::FunctionConfiguration',\n          Properties: {\n            Name: 'my-function',\n            ApiId: 'apiId',\n            DataSourceName: 'my-datasource',\n            FunctionVersion: '2018-05-29',\n            RequestMappingTemplate: '## original request template',\n            ResponseMappingTemplate: '## new response template',\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\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(mockUpdateFunction).toHaveBeenCalledWith({\n    apiId: 'apiId',\n    dataSourceName: 'my-datasource',\n    functionId: 'functionId',\n    functionVersion: '2018-05-29',\n    name: 'my-function',\n    requestMappingTemplate: '## original request template',\n    responseMappingTemplate: '## new response template',\n  });\n});\n\ntest('does not call the updateFunction() API when it receives a change that is not a mapping template difference in a Function', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncFunction: {\n        Type: 'AWS::AppSync::FunctionConfiguration',\n        Properties: {\n          RequestMappingTemplate: '## original template',\n          Name: 'my-function',\n          DataSourceName: 'my-datasource',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncFunction: {\n          Type: 'AWS::AppSync::FunctionConfiguration',\n          Properties: {\n            RequestMappingTemplate: '## new template',\n            Name: 'my-function',\n            DataSourceName: 'new-datasource',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateFunction).not.toHaveBeenCalled();\n});\n\ntest('does not call the updateFunction() API when a resource with type that is not AWS::AppSync::FunctionConfiguration but has the same properties is changed', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      AppSyncFunction: {\n        Type: 'AWS::AppSync::NotAFunctionConfiguration',\n        Properties: {\n          RequestMappingTemplate: '## original template',\n          Name: 'my-function',\n          DataSourceName: 'my-datasource',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        AppSyncFunction: {\n          Type: 'AWS::AppSync::NotAFunctionConfiguration',\n          Properties: {\n            RequestMappingTemplate: '## new template',\n            Name: 'my-resolver',\n            DataSourceName: 'my-datasource',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateFunction).not.toHaveBeenCalled();\n});\n"]}

package/test/api/hotswap/hotswap-deployments.test.js

@@ -7,7 +7,7 @@ let mockUpdateMachineDefinition;
 let mockGetEndpointSuffix;
 beforeEach(() => {
     hotswapMockSdkProvider = setup.setupHotswapTests();
-    mockUpdateLambdaCode = jest.fn();
+    mockUpdateLambdaCode = jest.fn().mockReturnValue({});
     mockUpdateMachineDefinition = jest.fn();
     mockGetEndpointSuffix = jest.fn(() => 'amazonaws.com');
     hotswapMockSdkProvider.stubLambda({
@@ -295,4 +295,4 @@ test('can correctly reference AWS::URLSuffix in hotswappable changes', async ()
     expect(hotswapMockSdkProvider.mockSdkProvider.sdk.removeCustomUserAgent)
         .toHaveBeenCalledWith('cdk-hotswap/success-lambda-function');
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotswap-deployments.test.js","sourceRoot":"","sources":["hotswap-deployments.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Lambda, StepFunctions } from 'aws-sdk';\nimport * as setup from './hotswap-test-setup';\n\nlet hotswapMockSdkProvider: setup.HotswapMockSdkProvider;\nlet mockUpdateLambdaCode: (params: Lambda.Types.UpdateFunctionCodeRequest) => Lambda.Types.FunctionConfiguration;\nlet mockUpdateMachineDefinition: (params: StepFunctions.Types.UpdateStateMachineInput) => StepFunctions.Types.UpdateStateMachineOutput;\nlet mockGetEndpointSuffix: () => string;\n\nbeforeEach(() => {\n  hotswapMockSdkProvider = setup.setupHotswapTests();\n  mockUpdateLambdaCode = jest.fn();\n  mockUpdateMachineDefinition = jest.fn();\n  mockGetEndpointSuffix = jest.fn(() => 'amazonaws.com');\n  hotswapMockSdkProvider.stubLambda({\n    updateFunctionCode: mockUpdateLambdaCode,\n  });\n  hotswapMockSdkProvider.setUpdateStateMachineMock(mockUpdateMachineDefinition);\n  hotswapMockSdkProvider.stubGetEndpointSuffix(mockGetEndpointSuffix);\n});\n\ntest('returns a deployStackResult with noOp=true when it receives an empty set of changes', async () => {\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(setup.cdkStackArtifactOf());\n\n  // THEN\n  expect(deployStackResult).not.toBeUndefined();\n  expect(deployStackResult?.noOp).toBeTruthy();\n  expect(deployStackResult?.stackArn).toEqual(setup.STACK_ID);\n});\n\ntest('A change to only a non-hotswappable resource results in a full deployment', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      SomethingElse: {\n        Type: 'AWS::CloudFormation::SomethingElse',\n        Properties: {\n          Prop: 'old-value',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        SomethingElse: {\n          Type: 'AWS::CloudFormation::SomethingElse',\n          Properties: {\n            Prop: 'new-value',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n});\n\ntest('A change to both a hotswappable resource and a non-hotswappable resource results in a full deployment', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            S3Bucket: 'current-bucket',\n            S3Key: 'current-key',\n          },\n          FunctionName: 'my-function',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n      SomethingElse: {\n        Type: 'AWS::CloudFormation::SomethingElse',\n        Properties: {\n          Prop: 'old-value',\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              S3Bucket: 'current-bucket',\n              S3Key: 'new-key',\n            },\n            FunctionName: 'my-function',\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\n          },\n        },\n        SomethingElse: {\n          Type: 'AWS::CloudFormation::SomethingElse',\n          Properties: {\n            Prop: 'new-value',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n});\n\ntest('changes only to CDK::Metadata result in a noOp', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      MetaData: {\n        Type: 'AWS::CDK::MetaData',\n        Properties: {\n          Prop: 'old-value',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        MetaData: {\n          Type: 'AWS::CDK::Metadata',\n          Properties: {\n            Prop: 'new-value',\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(deployStackResult?.noOp).toEqual(true);\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n});\n\ntest('resource deletions require full deployments', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Machine: {\n        Type: 'AWS::StepFunctions::StateMachine',\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf();\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n});\n\ntest('can correctly reference AWS::Partition in hotswappable changes', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            S3Bucket: 'current-bucket',\n            S3Key: 'current-key',\n          },\n          FunctionName: {\n            'Fn::Join': [\n              '',\n              [\n                { Ref: 'AWS::Partition' },\n                '-',\n                'my-function',\n              ],\n            ],\n          },\n        },\n        Metadata: {\n          'aws:asset:path': 'new-path',\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              S3Bucket: 'current-bucket',\n              S3Key: 'new-key',\n            },\n            FunctionName: {\n              'Fn::Join': [\n                '',\n                [\n                  { Ref: 'AWS::Partition' },\n                  '-',\n                  'my-function',\n                ],\n              ],\n            },\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\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: 'aws-my-function',\n    S3Bucket: 'current-bucket',\n    S3Key: 'new-key',\n  });\n});\n\ntest('can correctly reference AWS::URLSuffix in hotswappable changes', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            S3Bucket: 'current-bucket',\n            S3Key: 'current-key',\n          },\n          FunctionName: {\n            'Fn::Join': ['', [\n              'my-function-',\n              { Ref: 'AWS::URLSuffix' },\n              '-',\n              { Ref: 'AWS::URLSuffix' },\n            ]],\n          },\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\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              S3Bucket: 'current-bucket',\n              S3Key: 'new-key',\n            },\n            FunctionName: {\n              'Fn::Join': ['', [\n                'my-function-',\n                { Ref: 'AWS::URLSuffix' },\n                '-',\n                { Ref: 'AWS::URLSuffix' },\n              ]],\n            },\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\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-amazonaws.com-amazonaws.com',\n    S3Bucket: 'current-bucket',\n    S3Key: 'new-key',\n  });\n  expect(mockGetEndpointSuffix).toHaveBeenCalledTimes(1);\n\n  // the User-Agent is set correctly\n  expect(hotswapMockSdkProvider.mockSdkProvider.sdk.appendCustomUserAgent)\n    .toHaveBeenCalledWith('cdk-hotswap/success-lambda-function');\n  expect(hotswapMockSdkProvider.mockSdkProvider.sdk.removeCustomUserAgent)\n    .toHaveBeenCalledWith('cdk-hotswap/success-lambda-function');\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotswap-deployments.test.js","sourceRoot":"","sources":["hotswap-deployments.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Lambda, StepFunctions } from 'aws-sdk';\nimport * as setup from './hotswap-test-setup';\n\nlet hotswapMockSdkProvider: setup.HotswapMockSdkProvider;\nlet mockUpdateLambdaCode: (params: Lambda.Types.UpdateFunctionCodeRequest) => Lambda.Types.FunctionConfiguration;\nlet mockUpdateMachineDefinition: (params: StepFunctions.Types.UpdateStateMachineInput) => StepFunctions.Types.UpdateStateMachineOutput;\nlet mockGetEndpointSuffix: () => string;\n\nbeforeEach(() => {\n  hotswapMockSdkProvider = setup.setupHotswapTests();\n  mockUpdateLambdaCode = jest.fn().mockReturnValue({});\n  mockUpdateMachineDefinition = jest.fn();\n  mockGetEndpointSuffix = jest.fn(() => 'amazonaws.com');\n  hotswapMockSdkProvider.stubLambda({\n    updateFunctionCode: mockUpdateLambdaCode,\n  });\n  hotswapMockSdkProvider.setUpdateStateMachineMock(mockUpdateMachineDefinition);\n  hotswapMockSdkProvider.stubGetEndpointSuffix(mockGetEndpointSuffix);\n});\n\ntest('returns a deployStackResult with noOp=true when it receives an empty set of changes', async () => {\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(setup.cdkStackArtifactOf());\n\n  // THEN\n  expect(deployStackResult).not.toBeUndefined();\n  expect(deployStackResult?.noOp).toBeTruthy();\n  expect(deployStackResult?.stackArn).toEqual(setup.STACK_ID);\n});\n\ntest('A change to only a non-hotswappable resource results in a full deployment', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      SomethingElse: {\n        Type: 'AWS::CloudFormation::SomethingElse',\n        Properties: {\n          Prop: 'old-value',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        SomethingElse: {\n          Type: 'AWS::CloudFormation::SomethingElse',\n          Properties: {\n            Prop: 'new-value',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n});\n\ntest('A change to both a hotswappable resource and a non-hotswappable resource results in a full deployment', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            S3Bucket: 'current-bucket',\n            S3Key: 'current-key',\n          },\n          FunctionName: 'my-function',\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\n        },\n      },\n      SomethingElse: {\n        Type: 'AWS::CloudFormation::SomethingElse',\n        Properties: {\n          Prop: 'old-value',\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              S3Bucket: 'current-bucket',\n              S3Key: 'new-key',\n            },\n            FunctionName: 'my-function',\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\n          },\n        },\n        SomethingElse: {\n          Type: 'AWS::CloudFormation::SomethingElse',\n          Properties: {\n            Prop: 'new-value',\n          },\n        },\n      },\n    },\n  });\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n});\n\ntest('changes only to CDK::Metadata result in a noOp', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      MetaData: {\n        Type: 'AWS::CDK::MetaData',\n        Properties: {\n          Prop: 'old-value',\n        },\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf({\n    template: {\n      Resources: {\n        MetaData: {\n          Type: 'AWS::CDK::Metadata',\n          Properties: {\n            Prop: 'new-value',\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(deployStackResult?.noOp).toEqual(true);\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n});\n\ntest('resource deletions require full deployments', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Machine: {\n        Type: 'AWS::StepFunctions::StateMachine',\n      },\n    },\n  });\n  const cdkStackArtifact = setup.cdkStackArtifactOf();\n\n  // WHEN\n  const deployStackResult = await hotswapMockSdkProvider.tryHotswapDeployment(cdkStackArtifact);\n\n  // THEN\n  expect(deployStackResult).toBeUndefined();\n  expect(mockUpdateLambdaCode).not.toHaveBeenCalled();\n  expect(mockUpdateMachineDefinition).not.toHaveBeenCalled();\n});\n\ntest('can correctly reference AWS::Partition in hotswappable changes', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            S3Bucket: 'current-bucket',\n            S3Key: 'current-key',\n          },\n          FunctionName: {\n            'Fn::Join': [\n              '',\n              [\n                { Ref: 'AWS::Partition' },\n                '-',\n                'my-function',\n              ],\n            ],\n          },\n        },\n        Metadata: {\n          'aws:asset:path': 'new-path',\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              S3Bucket: 'current-bucket',\n              S3Key: 'new-key',\n            },\n            FunctionName: {\n              'Fn::Join': [\n                '',\n                [\n                  { Ref: 'AWS::Partition' },\n                  '-',\n                  'my-function',\n                ],\n              ],\n            },\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\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: 'aws-my-function',\n    S3Bucket: 'current-bucket',\n    S3Key: 'new-key',\n  });\n});\n\ntest('can correctly reference AWS::URLSuffix in hotswappable changes', async () => {\n  // GIVEN\n  setup.setCurrentCfnStackTemplate({\n    Resources: {\n      Func: {\n        Type: 'AWS::Lambda::Function',\n        Properties: {\n          Code: {\n            S3Bucket: 'current-bucket',\n            S3Key: 'current-key',\n          },\n          FunctionName: {\n            'Fn::Join': ['', [\n              'my-function-',\n              { Ref: 'AWS::URLSuffix' },\n              '-',\n              { Ref: 'AWS::URLSuffix' },\n            ]],\n          },\n        },\n        Metadata: {\n          'aws:asset:path': 'old-path',\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              S3Bucket: 'current-bucket',\n              S3Key: 'new-key',\n            },\n            FunctionName: {\n              'Fn::Join': ['', [\n                'my-function-',\n                { Ref: 'AWS::URLSuffix' },\n                '-',\n                { Ref: 'AWS::URLSuffix' },\n              ]],\n            },\n          },\n          Metadata: {\n            'aws:asset:path': 'new-path',\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-amazonaws.com-amazonaws.com',\n    S3Bucket: 'current-bucket',\n    S3Key: 'new-key',\n  });\n  expect(mockGetEndpointSuffix).toHaveBeenCalledTimes(1);\n\n  // the User-Agent is set correctly\n  expect(hotswapMockSdkProvider.mockSdkProvider.sdk.appendCustomUserAgent)\n    .toHaveBeenCalledWith('cdk-hotswap/success-lambda-function');\n  expect(hotswapMockSdkProvider.mockSdkProvider.sdk.removeCustomUserAgent)\n    .toHaveBeenCalledWith('cdk-hotswap/success-lambda-function');\n});\n"]}

package/test/api/hotswap/hotswap-test-setup.d.ts

@@ -18,8 +18,14 @@ export declare class HotswapMockSdkProvider {
     readonly mockSdkProvider: MockSdkProvider;
     constructor();
     setUpdateStateMachineMock(mockUpdateMachineDefinition: (input: stepfunctions.UpdateStateMachineInput) => stepfunctions.UpdateStateMachineOutput): void;
-    stubLambda(stubs: SyncHandlerSubsetOf<AWS.Lambda>): void;
+    stubLambda(stubs: SyncHandlerSubsetOf<AWS.Lambda>, serviceStubs?: SyncHandlerSubsetOf<AWS.Service>, additionalProperties?: {
+        [key: string]: any;
+    }): void;
+    getLambdaApiWaiters(): {
+        [key: string]: any;
+    };
     setUpdateProjectMock(mockUpdateProject: (input: codebuild.UpdateProjectInput) => codebuild.UpdateProjectOutput): void;
+    stubAppSync(stubs: SyncHandlerSubsetOf<AWS.AppSync>): void;
     setInvokeLambdaMock(mockInvokeLambda: (input: lambda.InvocationRequest) => lambda.InvocationResponse): void;
     stubEcs(stubs: SyncHandlerSubsetOf<AWS.ECS>, additionalProperties?: {
         [key: string]: any;

package/test/api/hotswap/hotswap-test-setup.js

@@ -67,14 +67,33 @@ class HotswapMockSdkProvider {
             updateStateMachine: mockUpdateMachineDefinition,
         });
     }
-    stubLambda(stubs) {
-        this.mockSdkProvider.stubLambda(stubs);
+    stubLambda(stubs, serviceStubs, additionalProperties = {}) {
+        this.mockSdkProvider.stubLambda(stubs, {
+            api: {
+                waiters: {},
+            },
+            makeRequest() {
+                return {
+                    promise: () => Promise.resolve({}),
+                    response: {},
+                    addListeners: () => { },
+                };
+            },
+            ...serviceStubs,
+            ...additionalProperties,
+        });
+    }
+    getLambdaApiWaiters() {
+        return this.mockSdkProvider.sdk.lambda().api.waiters;
     }
     setUpdateProjectMock(mockUpdateProject) {
         this.mockSdkProvider.stubCodeBuild({
             updateProject: mockUpdateProject,
         });
     }
+    stubAppSync(stubs) {
+        this.mockSdkProvider.stubAppSync(stubs);
+    }
     setInvokeLambdaMock(mockInvokeLambda) {
         this.mockSdkProvider.stubLambda({
             invoke: mockInvokeLambda,
@@ -91,4 +110,4 @@ class HotswapMockSdkProvider {
     }
 }
 exports.HotswapMockSdkProvider = HotswapMockSdkProvider;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotswap-test-setup.js","sourceRoot":"","sources":["hotswap-test-setup.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport { CloudFormation } from 'aws-sdk';\nimport * as AWS from 'aws-sdk';\nimport * as codebuild from 'aws-sdk/clients/codebuild';\nimport * as lambda from 'aws-sdk/clients/lambda';\nimport * as stepfunctions from 'aws-sdk/clients/stepfunctions';\nimport { DeployStackResult } from '../../../lib/api';\nimport * as deployments from '../../../lib/api/hotswap-deployments';\nimport { Template } from '../../../lib/api/util/cloudformation';\nimport { testStack, TestStackArtifact } from '../../util';\nimport { MockSdkProvider, SyncHandlerSubsetOf } from '../../util/mock-sdk';\nimport { FakeCloudformationStack } from '../fake-cloudformation-stack';\n\nconst STACK_NAME = 'withouterrors';\nexport const STACK_ID = 'stackId';\n\nlet hotswapMockSdkProvider: HotswapMockSdkProvider;\nlet currentCfnStack: FakeCloudformationStack;\nconst currentCfnStackResources: CloudFormation.StackResourceSummary[] = [];\n\nexport function setupHotswapTests() {\n  jest.resetAllMocks();\n  // clear the array\n  currentCfnStackResources.splice(0);\n  hotswapMockSdkProvider = new HotswapMockSdkProvider();\n  currentCfnStack = new FakeCloudformationStack({\n    stackName: STACK_NAME,\n    stackId: STACK_ID,\n  });\n\n  return hotswapMockSdkProvider;\n}\n\nexport function cdkStackArtifactOf(testStackArtifact: Partial<TestStackArtifact> = {}): cxapi.CloudFormationStackArtifact {\n  return testStack({\n    stackName: STACK_NAME,\n    ...testStackArtifact,\n  });\n}\n\nexport function pushStackResourceSummaries(...items: CloudFormation.StackResourceSummary[]) {\n  currentCfnStackResources.push(...items);\n}\n\nexport function setCurrentCfnStackTemplate(template: Template) {\n  const templateDeepCopy = JSON.parse(JSON.stringify(template)); // deep copy the template, so our tests can mutate one template instead of creating two\n  currentCfnStack.setTemplate(templateDeepCopy);\n}\n\nexport function stackSummaryOf(logicalId: string, resourceType: string, physicalResourceId: string): CloudFormation.StackResourceSummary {\n  return {\n    LogicalResourceId: logicalId,\n    PhysicalResourceId: physicalResourceId,\n    ResourceType: resourceType,\n    ResourceStatus: 'CREATE_COMPLETE',\n    LastUpdatedTimestamp: new Date(),\n  };\n}\n\nexport class HotswapMockSdkProvider {\n  public readonly mockSdkProvider: MockSdkProvider;\n\n  constructor() {\n    this.mockSdkProvider = new MockSdkProvider({ realSdk: false });\n\n    this.mockSdkProvider.stubCloudFormation({\n      listStackResources: ({ StackName: stackName }) => {\n        if (stackName !== STACK_NAME) {\n          throw new Error(`Expected Stack name in listStackResources() call to be: '${STACK_NAME}', but received: ${stackName}'`);\n        }\n        return {\n          StackResourceSummaries: currentCfnStackResources,\n        };\n      },\n    });\n  }\n\n  public setUpdateStateMachineMock(\n    mockUpdateMachineDefinition: (input: stepfunctions.UpdateStateMachineInput) => stepfunctions.UpdateStateMachineOutput,\n  ) {\n    this.mockSdkProvider.stubStepFunctions({\n      updateStateMachine: mockUpdateMachineDefinition,\n    });\n  }\n\n  public stubLambda(stubs: SyncHandlerSubsetOf<AWS.Lambda>) {\n    this.mockSdkProvider.stubLambda(stubs);\n  }\n\n  public setUpdateProjectMock(mockUpdateProject: (input: codebuild.UpdateProjectInput) => codebuild.UpdateProjectOutput) {\n    this.mockSdkProvider.stubCodeBuild({\n      updateProject: mockUpdateProject,\n    });\n  }\n\n  public setInvokeLambdaMock(mockInvokeLambda: (input: lambda.InvocationRequest) => lambda.InvocationResponse) {\n    this.mockSdkProvider.stubLambda({\n      invoke: mockInvokeLambda,\n    });\n  }\n\n  public stubEcs(stubs: SyncHandlerSubsetOf<AWS.ECS>, additionalProperties: { [key: string]: any } = {}): void {\n    this.mockSdkProvider.stubEcs(stubs, additionalProperties);\n  }\n\n  public stubGetEndpointSuffix(stub: () => string) {\n    this.mockSdkProvider.stubGetEndpointSuffix(stub);\n  }\n\n  public tryHotswapDeployment(\n    stackArtifact: cxapi.CloudFormationStackArtifact,\n    assetParams: { [key: string]: string } = {},\n  ): Promise<DeployStackResult | undefined> {\n    return deployments.tryHotswapDeployment(this.mockSdkProvider, assetParams, currentCfnStack, stackArtifact);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotswap-test-setup.js","sourceRoot":"","sources":["hotswap-test-setup.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport { CloudFormation } from 'aws-sdk';\nimport * as AWS from 'aws-sdk';\nimport * as codebuild from 'aws-sdk/clients/codebuild';\nimport * as lambda from 'aws-sdk/clients/lambda';\nimport * as stepfunctions from 'aws-sdk/clients/stepfunctions';\nimport { DeployStackResult } from '../../../lib/api';\nimport * as deployments from '../../../lib/api/hotswap-deployments';\nimport { Template } from '../../../lib/api/util/cloudformation';\nimport { testStack, TestStackArtifact } from '../../util';\nimport { MockSdkProvider, SyncHandlerSubsetOf } from '../../util/mock-sdk';\nimport { FakeCloudformationStack } from '../fake-cloudformation-stack';\n\nconst STACK_NAME = 'withouterrors';\nexport const STACK_ID = 'stackId';\n\nlet hotswapMockSdkProvider: HotswapMockSdkProvider;\nlet currentCfnStack: FakeCloudformationStack;\nconst currentCfnStackResources: CloudFormation.StackResourceSummary[] = [];\n\nexport function setupHotswapTests() {\n  jest.resetAllMocks();\n  // clear the array\n  currentCfnStackResources.splice(0);\n  hotswapMockSdkProvider = new HotswapMockSdkProvider();\n  currentCfnStack = new FakeCloudformationStack({\n    stackName: STACK_NAME,\n    stackId: STACK_ID,\n  });\n\n  return hotswapMockSdkProvider;\n}\n\nexport function cdkStackArtifactOf(testStackArtifact: Partial<TestStackArtifact> = {}): cxapi.CloudFormationStackArtifact {\n  return testStack({\n    stackName: STACK_NAME,\n    ...testStackArtifact,\n  });\n}\n\nexport function pushStackResourceSummaries(...items: CloudFormation.StackResourceSummary[]) {\n  currentCfnStackResources.push(...items);\n}\n\nexport function setCurrentCfnStackTemplate(template: Template) {\n  const templateDeepCopy = JSON.parse(JSON.stringify(template)); // deep copy the template, so our tests can mutate one template instead of creating two\n  currentCfnStack.setTemplate(templateDeepCopy);\n}\n\nexport function stackSummaryOf(logicalId: string, resourceType: string, physicalResourceId: string): CloudFormation.StackResourceSummary {\n  return {\n    LogicalResourceId: logicalId,\n    PhysicalResourceId: physicalResourceId,\n    ResourceType: resourceType,\n    ResourceStatus: 'CREATE_COMPLETE',\n    LastUpdatedTimestamp: new Date(),\n  };\n}\n\nexport class HotswapMockSdkProvider {\n  public readonly mockSdkProvider: MockSdkProvider;\n\n  constructor() {\n    this.mockSdkProvider = new MockSdkProvider({ realSdk: false });\n\n    this.mockSdkProvider.stubCloudFormation({\n      listStackResources: ({ StackName: stackName }) => {\n        if (stackName !== STACK_NAME) {\n          throw new Error(`Expected Stack name in listStackResources() call to be: '${STACK_NAME}', but received: ${stackName}'`);\n        }\n        return {\n          StackResourceSummaries: currentCfnStackResources,\n        };\n      },\n    });\n  }\n\n  public setUpdateStateMachineMock(\n    mockUpdateMachineDefinition: (input: stepfunctions.UpdateStateMachineInput) => stepfunctions.UpdateStateMachineOutput,\n  ) {\n    this.mockSdkProvider.stubStepFunctions({\n      updateStateMachine: mockUpdateMachineDefinition,\n    });\n  }\n\n  public stubLambda(\n    stubs: SyncHandlerSubsetOf<AWS.Lambda>,\n    serviceStubs?: SyncHandlerSubsetOf<AWS.Service>,\n    additionalProperties: { [key: string]: any } = {},\n  ): void {\n    this.mockSdkProvider.stubLambda(stubs, {\n      api: {\n        waiters: {},\n      },\n      makeRequest() {\n        return {\n          promise: () => Promise.resolve({}),\n          response: {},\n          addListeners: () => {},\n        };\n      },\n      ...serviceStubs,\n      ...additionalProperties,\n    });\n  }\n\n  public getLambdaApiWaiters(): { [key: string]: any } {\n    return (this.mockSdkProvider.sdk.lambda() as any).api.waiters;\n  }\n\n  public setUpdateProjectMock(mockUpdateProject: (input: codebuild.UpdateProjectInput) => codebuild.UpdateProjectOutput) {\n    this.mockSdkProvider.stubCodeBuild({\n      updateProject: mockUpdateProject,\n    });\n  }\n\n  public stubAppSync(stubs: SyncHandlerSubsetOf<AWS.AppSync>) {\n    this.mockSdkProvider.stubAppSync(stubs);\n  }\n\n  public setInvokeLambdaMock(mockInvokeLambda: (input: lambda.InvocationRequest) => lambda.InvocationResponse) {\n    this.mockSdkProvider.stubLambda({\n      invoke: mockInvokeLambda,\n    });\n  }\n\n  public stubEcs(stubs: SyncHandlerSubsetOf<AWS.ECS>, additionalProperties: { [key: string]: any } = {}): void {\n    this.mockSdkProvider.stubEcs(stubs, additionalProperties);\n  }\n\n  public stubGetEndpointSuffix(stub: () => string) {\n    this.mockSdkProvider.stubGetEndpointSuffix(stub);\n  }\n\n  public tryHotswapDeployment(\n    stackArtifact: cxapi.CloudFormationStackArtifact,\n    assetParams: { [key: string]: string } = {},\n  ): Promise<DeployStackResult | undefined> {\n    return deployments.tryHotswapDeployment(this.mockSdkProvider, assetParams, currentCfnStack, stackArtifact);\n  }\n}\n"]}