aws-cdk 2.12.0 → 2.13.0

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-test-setup.d.ts

@@ -25,6 +25,7 @@ export declare class HotswapMockSdkProvider {
         [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

@@ -91,6 +91,9 @@ class HotswapMockSdkProvider {
             updateProject: mockUpdateProject,
         });
     }
+    stubAppSync(stubs) {
+        this.mockSdkProvider.stubAppSync(stubs);
+    }
     setInvokeLambdaMock(mockInvokeLambda) {
         this.mockSdkProvider.stubLambda({
             invoke: mockInvokeLambda,
@@ -107,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(\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 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"]}