@aws-cdk/integ-tests-alpha - npm Package Compare versions

Comparing version 2.24.1-alpha.0 to 2.25.0-alpha.0

.warnings.jsii.js

@@ -15,2 +15,6 @@ function _aws_cdk_integ_tests_alpha_IntegTestCaseProps(p) {
 }
+function _aws_cdk_integ_tests_alpha_IntegTestCaseStackProps(p) {
+}
+function _aws_cdk_integ_tests_alpha_IntegTestCaseStack(p) {
+}
 function _aws_cdk_integ_tests_alpha_IntegTestProps(p) {
@@ -22,3 +26,3 @@ if (p == null)
         if (!visitedObjects.has(p.testCases))
-            _aws_cdk_integ_tests_alpha_IntegTestCase(p.testCases);
+            require("aws-cdk-lib/.warnings.jsii.js").aws_cdk_lib_Stack(p.testCases);
     }
@@ -31,2 +35,94 @@ finally {
 }
+function _aws_cdk_integ_tests_alpha_EqualsAssertionProps(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.actual))
+            _aws_cdk_integ_tests_alpha_ActualResult(p.actual);
+        if (!visitedObjects.has(p.expected))
+            _aws_cdk_integ_tests_alpha_ExpectedResult(p.expected);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_integ_tests_alpha_EqualsAssertion(p) {
+}
+function _aws_cdk_integ_tests_alpha_AwsApiCallOptions(p) {
+}
+function _aws_cdk_integ_tests_alpha_AwsApiCallProps(p) {
+}
+function _aws_cdk_integ_tests_alpha_AwsApiCall(p) {
+}
+function _aws_cdk_integ_tests_alpha_LogType(p) {
+}
+function _aws_cdk_integ_tests_alpha_InvocationType(p) {
+}
+function _aws_cdk_integ_tests_alpha_LambdaInvokeFunctionProps(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.invocationType))
+            _aws_cdk_integ_tests_alpha_InvocationType(p.invocationType);
+        if (!visitedObjects.has(p.logType))
+            _aws_cdk_integ_tests_alpha_LogType(p.logType);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_integ_tests_alpha_LambdaInvokeFunction(p) {
+}
+function _aws_cdk_integ_tests_alpha_DeployAssertProps(p) {
+}
+function _aws_cdk_integ_tests_alpha_DeployAssert(p) {
+}
+function _aws_cdk_integ_tests_alpha_AwsApiCallRequest(p) {
+}
+function _aws_cdk_integ_tests_alpha_AwsApiCallResult(p) {
+}
+function _aws_cdk_integ_tests_alpha_AssertionType(p) {
+}
+function _aws_cdk_integ_tests_alpha_AssertionRequest(p) {
+}
+function _aws_cdk_integ_tests_alpha_AssertionResult(p) {
+}
+function _aws_cdk_integ_tests_alpha_Status(p) {
+}
+function _aws_cdk_integ_tests_alpha_AssertionResultData(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.status))
+            _aws_cdk_integ_tests_alpha_Status(p.status);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_integ_tests_alpha_ResultsCollectionRequest(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.assertionResults))
+            _aws_cdk_integ_tests_alpha_AssertionResultData(p.assertionResults);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_integ_tests_alpha_ResultsCollectionResult(p) {
+}
+function _aws_cdk_integ_tests_alpha_AssertionsProvider(p) {
+}
+function _aws_cdk_integ_tests_alpha_ActualResult(p) {
+}
+function _aws_cdk_integ_tests_alpha_ExpectedResult(p) {
+}
+function _aws_cdk_integ_tests_alpha_Match(p) {
+}
 function print(name, deprecationMessage) {
@@ -68,2 +164,2 @@ const deprecated = process.env.JSII_DEPRECATED;
 }
-module.exports = { print, getPropertyDescriptor, DeprecationError, _aws_cdk_integ_tests_alpha_IntegTestCaseProps, _aws_cdk_integ_tests_alpha_IntegTestCase, _aws_cdk_integ_tests_alpha_IntegTestProps, _aws_cdk_integ_tests_alpha_IntegTest };
+module.exports = { print, getPropertyDescriptor, DeprecationError, _aws_cdk_integ_tests_alpha_IntegTestCaseProps, _aws_cdk_integ_tests_alpha_IntegTestCase, _aws_cdk_integ_tests_alpha_IntegTestCaseStackProps, _aws_cdk_integ_tests_alpha_IntegTestCaseStack, _aws_cdk_integ_tests_alpha_IntegTestProps, _aws_cdk_integ_tests_alpha_IntegTest, _aws_cdk_integ_tests_alpha_EqualsAssertionProps, _aws_cdk_integ_tests_alpha_EqualsAssertion, _aws_cdk_integ_tests_alpha_AwsApiCallOptions, _aws_cdk_integ_tests_alpha_AwsApiCallProps, _aws_cdk_integ_tests_alpha_AwsApiCall, _aws_cdk_integ_tests_alpha_LogType, _aws_cdk_integ_tests_alpha_InvocationType, _aws_cdk_integ_tests_alpha_LambdaInvokeFunctionProps, _aws_cdk_integ_tests_alpha_LambdaInvokeFunction, _aws_cdk_integ_tests_alpha_DeployAssertProps, _aws_cdk_integ_tests_alpha_DeployAssert, _aws_cdk_integ_tests_alpha_AwsApiCallRequest, _aws_cdk_integ_tests_alpha_AwsApiCallResult, _aws_cdk_integ_tests_alpha_AssertionType, _aws_cdk_integ_tests_alpha_AssertionRequest, _aws_cdk_integ_tests_alpha_AssertionResult, _aws_cdk_integ_tests_alpha_Status, _aws_cdk_integ_tests_alpha_AssertionResultData, _aws_cdk_integ_tests_alpha_ResultsCollectionRequest, _aws_cdk_integ_tests_alpha_ResultsCollectionResult, _aws_cdk_integ_tests_alpha_AssertionsProvider, _aws_cdk_integ_tests_alpha_ActualResult, _aws_cdk_integ_tests_alpha_ExpectedResult, _aws_cdk_integ_tests_alpha_Match };

lib/assertions/assertions.d.ts

@@ -1,3 +0,2 @@
-import { CustomResource } from 'aws-cdk-lib';
-import { IAssertion } from './deploy-assert';
+import { ExpectedResult, ActualResult } from './common';
 import { Construct } from 'constructs';
@@ -9,13 +8,19 @@ /**
     /**
-     * The CustomResource that continains the "actual" results
+     * The actual results to compare
      */
-    readonly inputResource: CustomResource;
+    readonly actual: ActualResult;
     /**
-     * The CustomResource attribute that continains the "actual" results
+     * The expected result to assert
      */
-    readonly inputResourceAtt: string;
+    readonly expected: ExpectedResult;
     /**
-     * The expected result to assert
+     * Set this to true if a failed assertion should
+     * result in a CloudFormation deployment failure
+     *
+     * This is only necessary if assertions are being
+     * executed outside of `integ-runner`.
+     *
+     * @default false
      */
-    readonly expected: any;
+    readonly failDeployment?: boolean;
 }
@@ -26,5 +31,8 @@ /**
  */
-export declare class EqualsAssertion extends Construct implements IAssertion {
+export declare class EqualsAssertion extends Construct {
+    /**
+     * The result of the assertion
+     */
     readonly result: string;
     constructor(scope: Construct, id: string, props: EqualsAssertionProps);
 }

lib/assertions/assertions.js

 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EqualsAssertion = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
@@ -16,17 +19,34 @@ const providers_1 = require("./providers");
         super(scope, id);
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_EqualsAssertionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.constructor);
+            }
+            throw error;
+        }
         const assertionProvider = new providers_1.AssertionsProvider(this, 'AssertionProvider');
         const properties = {
-            actual: props.inputResource.getAttString(props.inputResourceAtt),
-            expected: props.expected,
-            assertionType: providers_1.AssertionType.EQUALS,
+            actual: props.actual.result,
+            expected: props.expected.result,
+            failDeployment: props.failDeployment,
         };
         const resource = new aws_cdk_lib_1.CustomResource(this, 'Default', {
             serviceToken: assertionProvider.serviceToken,
-            properties,
+            properties: {
+                ...properties,
+                salt: Date.now().toString(),
+            },
             resourceType: providers_1.ASSERT_RESOURCE_TYPE,
         });
         this.result = resource.getAttString('data');
+        new aws_cdk_lib_1.CfnOutput(this, 'AssertionResults', {
+            value: this.result,
+        }).overrideLogicalId(`AssertionResults${id}`);
     }
 }
 exports.EqualsAssertion = EqualsAssertion;
-//# sourceMappingURL=data:application/json;base64,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
+_a = JSII_RTTI_SYMBOL_1;
+EqualsAssertion[_a] = { fqn: "@aws-cdk/integ-tests-alpha.EqualsAssertion", version: "2.25.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,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

lib/assertions/deploy-assert.d.ts

 import { IConstruct } from 'constructs';
-import { SdkQuery, SdkQueryOptions } from './sdk';
+import { ExpectedResult, ActualResult } from './common';
+import { AwsApiCall, LambdaInvokeFunction, LambdaInvokeFunctionProps } from './sdk';
 import { Construct } from 'constructs';
 /**
- * Represents a deploy time assertion
- */
-export interface IAssertion {
-    /**
-     * The result of the assertion
-     */
-    readonly result: string;
-}
-/**
  * Options for DeployAssert
@@ -31,14 +23,51 @@ */
     static of(construct: IConstruct): DeployAssert;
-    /** @internal */
-    readonly _assertions: IAssertion[];
     constructor(scope: Construct);
     /**
-     * Query AWS using JavaScript SDK V2 API calls
+     * Query AWS using JavaScript SDK V2 API calls. This can be used to either
+     * trigger an action or to return a result that can then be asserted against
+     * an expected value
+     *
+     * @example
+     * declare const app: App;
+     * const assert = new DeployAssert(app);
+     * assert.awsApiCall('SQS', 'sendMessage', {
+     *   QueueUrl: 'url',
+     *   MessageBody: 'hello',
+     * });
+     * const message = assert.awsApiCall('SQS', 'receiveMessage', {
+     *   QueueUrl: 'url',
+     * });
+     * message.assert(ExpectedResult.objectLike({
+     *   Messages: [{ Body: 'hello' }],
+     * }));
      */
-    queryAws(options: SdkQueryOptions): SdkQuery;
+    awsApiCall(service: string, api: string, parameters?: any): AwsApiCall;
     /**
-     * Register an assertion that should be run as part of the
-     * deployment
+     * Invoke a lambda function and return the response which can be asserted
+     *
+     * @example
+     * declare const app: App;
+     * const assert = new DeployAssert(app);
+     * const invoke = assert.invokeFunction({
+     *   functionName: 'my-function',
+     * });
+     * invoke.assert(ExpectedResult.objectLike({
+     *   Payload: '200',
+     * }));
      */
-    registerAssertion(assertion: IAssertion): void;
+    invokeFunction(props: LambdaInvokeFunctionProps): LambdaInvokeFunction;
+    /**
+     * Assert that the ExpectedResult is equal
+     * to the ActualResult
+     *
+     * @example
+     * declare const deployAssert: DeployAssert;
+     * declare const apiCall: AwsApiCall;
+     * deployAssert.assert(
+     *   'invoke',
+     *   ExpectedResult.objectLike({ Payload: 'OK' }),
+     *   ActualResult.fromAwsApiCall(apiCall, 'Body'),
+     * );
+     */
+    assert(id: string, expected: ExpectedResult, actual: ActualResult): void;
 }

lib/assertions/deploy-assert.js

 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeployAssert = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const constructs_1 = require("constructs");
+const assertions_1 = require("./assertions");
 const hash_1 = require("./private/hash");
-const providers_1 = require("./providers");
 const sdk_1 = require("./sdk");
@@ -19,19 +22,17 @@ const DEPLOY_ASSERT_SYMBOL = Symbol.for('@aws-cdk/integ-tests.DeployAssert');
     constructor(scope) {
-        super(scope, 'DeployAssert');
+        /**
+         * Normally we would not want to do a scope swapparoo like this
+         * but in this case this it allows us to provide a better experience
+         * for the user. This allows DeployAssert to be created _not_ in the
+         * scope of a Stack. DeployAssert is treated like a Stack, but doesn't
+         * exose any of the stack functionality (the methods that the user sees
+         * are just DeployAssert methods and not any Stack methods). So you can do
+         * something like this, which you would not normally be allowed to do
+         *
+         * const deployAssert = new DeployAssert(app);
+         * new AwsApiCall(deployAssert, 'AwsApiCall', {...});
+         */
+        scope = new aws_cdk_lib_1.Stack(scope, 'DeployAssert');
+        super(scope, 'Default');
         Object.defineProperty(this, DEPLOY_ASSERT_SYMBOL, { value: true });
-        this._assertions = [];
-        const provider = new providers_1.AssertionsProvider(this, 'ResultsProvider');
-        const resource = new aws_cdk_lib_1.CustomResource(this, 'ResultsCollection', {
-            serviceToken: provider.serviceToken,
-            properties: {
-                assertionResults: aws_cdk_lib_1.Lazy.list({
-                    produce: () => this._assertions.map(a => a.result),
-                }),
-            },
-            resourceType: providers_1.RESULTS_RESOURCE_TYPE,
-        });
-        // TODO: need to show/store this information
-        new aws_cdk_lib_1.CfnOutput(this, 'Results', {
-            value: `\n${resource.getAttString('message')}`,
-        }).overrideLogicalId('Results');
     }
@@ -48,3 +49,3 @@ /**
     static of(construct) {
-        const scopes = constructs_1.Node.of(construct).scopes.reverse();
+        const scopes = constructs_1.Node.of(constructs_1.Node.of(construct).root).findAll();
         const deployAssert = scopes.find(s => DeployAssert.isDeployAssert(s));
@@ -57,17 +58,86 @@ if (!deployAssert) {
     /**
-     * Query AWS using JavaScript SDK V2 API calls
+     * Query AWS using JavaScript SDK V2 API calls. This can be used to either
+     * trigger an action or to return a result that can then be asserted against
+     * an expected value
+     *
+     * @example
+     * declare const app: App;
+     * const assert = new DeployAssert(app);
+     * assert.awsApiCall('SQS', 'sendMessage', {
+     *   QueueUrl: 'url',
+     *   MessageBody: 'hello',
+     * });
+     * const message = assert.awsApiCall('SQS', 'receiveMessage', {
+     *   QueueUrl: 'url',
+     * });
+     * message.assert(ExpectedResult.objectLike({
+     *   Messages: [{ Body: 'hello' }],
+     * }));
      */
-    queryAws(options) {
-        const id = hash_1.md5hash(options);
-        return new sdk_1.SdkQuery(this, `SdkQuery${id}`, options);
+    awsApiCall(service, api, parameters) {
+        return new sdk_1.AwsApiCall(this, `AwsApiCall${service}${api}`, {
+            api,
+            service,
+            parameters,
+        });
     }
     /**
-     * Register an assertion that should be run as part of the
-     * deployment
+     * Invoke a lambda function and return the response which can be asserted
+     *
+     * @example
+     * declare const app: App;
+     * const assert = new DeployAssert(app);
+     * const invoke = assert.invokeFunction({
+     *   functionName: 'my-function',
+     * });
+     * invoke.assert(ExpectedResult.objectLike({
+     *   Payload: '200',
+     * }));
      */
-    registerAssertion(assertion) {
-        this._assertions.push(assertion);
+    invokeFunction(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_LambdaInvokeFunctionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.invokeFunction);
+            }
+            throw error;
+        }
+        const hash = hash_1.md5hash(aws_cdk_lib_1.Stack.of(this).resolve(props));
+        return new sdk_1.LambdaInvokeFunction(this, `LambdaInvoke${hash}`, props);
     }
+    /**
+     * Assert that the ExpectedResult is equal
+     * to the ActualResult
+     *
+     * @example
+     * declare const deployAssert: DeployAssert;
+     * declare const apiCall: AwsApiCall;
+     * deployAssert.assert(
+     *   'invoke',
+     *   ExpectedResult.objectLike({ Payload: 'OK' }),
+     *   ActualResult.fromAwsApiCall(apiCall, 'Body'),
+     * );
+     */
+    assert(id, expected, actual) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_ExpectedResult(expected);
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_ActualResult(actual);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.assert);
+            }
+            throw error;
+        }
+        new assertions_1.EqualsAssertion(this, `EqualsAssertion${id}`, {
+            expected,
+            actual,
+        });
+    }
 }
 exports.DeployAssert = DeployAssert;
-//# sourceMappingURL=data:application/json;base64,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
+_a = JSII_RTTI_SYMBOL_1;
+DeployAssert[_a] = { fqn: "@aws-cdk/integ-tests-alpha.DeployAssert", version: "2.25.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,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

lib/assertions/index.d.ts

@@ -5,1 +5,3 @@ export * from './assertions';
 export * from './providers';
+export * from './common';
+export * from './match';

lib/assertions/index.js

@@ -17,2 +17,4 @@ "use strict";
 __exportStar(require("./providers"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSwrQ0FBNkI7QUFDN0Isd0NBQXNCO0FBQ3RCLGtEQUFnQztBQUNoQyw4Q0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Fzc2VydGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZGsnO1xuZXhwb3J0ICogZnJvbSAnLi9kZXBsb3ktYXNzZXJ0JztcbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXJzJztcbiJdfQ==
+__exportStar(require("./common"), exports);
+__exportStar(require("./match"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSwrQ0FBNkI7QUFDN0Isd0NBQXNCO0FBQ3RCLGtEQUFnQztBQUNoQyw4Q0FBNEI7QUFDNUIsMkNBQXlCO0FBQ3pCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXNzZXJ0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3Nkayc7XG5leHBvcnQgKiBmcm9tICcuL2RlcGxveS1hc3NlcnQnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21tb24nO1xuZXhwb3J0ICogZnJvbSAnLi9tYXRjaCc7XG4iXX0=

lib/assertions/providers/lambda-handler/assertion.d.ts

 import { CustomResourceHandler } from './base';
-import { AssertionRequest, AssertionResult } from './types';
+import { AssertionResult, AssertionRequest } from './types';
 export declare class AssertionHandler extends CustomResourceHandler<AssertionRequest, AssertionResult> {
     protected processEvent(request: AssertionRequest): Promise<AssertionResult | undefined>;
 }

lib/assertions/providers/lambda-handler/assertion.js

@@ -5,31 +5,35 @@ "use strict";
 /* eslint-disable no-console */
-const assert = require("assert");
+// eslint-disable-next-line import/no-extraneous-dependencies
+const helpers_internal_1 = require("aws-cdk-lib/assertions/lib/helpers-internal");
 const base_1 = require("./base");
 class AssertionHandler extends base_1.CustomResourceHandler {
     async processEvent(request) {
+        let actual = decodeCall(request.actual);
+        const expected = decodeCall(request.expected);
         let result;
-        switch (request.assertionType) {
-            case 'equals':
-                console.log(`Testing equality between ${JSON.stringify(request.actual)} and ${JSON.stringify(request.expected)}`);
-                try {
-                    assert.deepStrictEqual(request.actual, request.expected);
-                    result = { data: { status: 'pass' } };
-                }
-                catch (e) {
-                    if (e instanceof assert.AssertionError) {
-                        result = {
-                            data: {
-                                status: 'fail',
-                                message: e.message,
-                            },
-                        };
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-                break;
-            default:
-                throw new Error(`Unsupported query type ${request.assertionType}`);
+        const matcher = new MatchCreator(expected).getMatcher();
+        console.log(`Testing equality between ${JSON.stringify(request.actual)} and ${JSON.stringify(request.expected)}`);
+        const matchResult = matcher.test(actual);
+        matchResult.finished();
+        if (matchResult.hasFailed()) {
+            result = {
+                data: JSON.stringify({
+                    status: 'fail',
+                    message: [
+                        ...matchResult.toHumanStrings(),
+                        JSON.stringify(matchResult.target, undefined, 2),
+                    ].join('\n'),
+                }),
+            };
+            if (request.failDeployment) {
+                throw new Error(result.data);
+            }
         }
+        else {
+            result = {
+                data: JSON.stringify({
+                    status: 'pass',
+                }),
+            };
+        }
         return result;
@@ -39,2 +43,96 @@ }
 exports.AssertionHandler = AssertionHandler;
-//# sourceMappingURL=data:application/json;base64,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
+class MatchCreator {
+    constructor(obj) {
+        this.parsedObj = {
+            matcher: obj,
+        };
+    }
+    /**
+     * Return a Matcher that can be tested against the actual results.
+     * This will convert the encoded matchers into their corresponding
+     * assertions matcher.
+     *
+     * For example:
+     *
+     * ExpectedResult.objectLike({
+     *   Messages: [{
+     *     Body: Match.objectLike({
+     *       Elements: Match.arrayWith([{ Asdf: 3 }]),
+     *     }),
+     *   }],
+     * });
+     *
+     * Will be encoded as:
+     * {
+     *   $ObjectLike: {
+     *     Messages: [{
+     *       Body: {
+     *         $ObjectLike: {
+     *           Elements: {
+     *             $ArrayWith: [{ Asdf: 3 }],
+     *           },
+     *         },
+     *       },
+     *     }],
+     *   },
+     * }
+     *
+     * Which can then be parsed by this function. For each key (recursively)
+     * the parser will check if the value has one of the encoded matchers as a key
+     * and if so, it will set the value as the Matcher. So,
+     *
+     * {
+     *   Body: {
+     *     $ObjectLike: {
+     *       Elements: {
+     *         $ArrayWith: [{ Asdf: 3 }],
+     *       },
+     *     },
+     *   },
+     * }
+     *
+     * Will be converted to
+     * {
+     *   Body: Match.objectLike({
+     *     Elements: Match.arrayWith([{ Asdf: 3 }]),
+     *   }),
+     * }
+     */
+    getMatcher() {
+        try {
+            const final = JSON.parse(JSON.stringify(this.parsedObj), function (_k, v) {
+                const nested = Object.keys(v)[0];
+                switch (nested) {
+                    case '$ArrayWith':
+                        return helpers_internal_1.Match.arrayWith(v[nested]);
+                    case '$ObjectLike':
+                        return helpers_internal_1.Match.objectLike(v[nested]);
+                    case '$StringLike':
+                        return helpers_internal_1.Match.stringLikeRegexp(v[nested]);
+                    default:
+                        return v;
+                }
+            });
+            if (helpers_internal_1.Matcher.isMatcher(final.matcher)) {
+                return final.matcher;
+            }
+            return helpers_internal_1.Match.exact(final.matcher);
+        }
+        catch {
+            return helpers_internal_1.Match.exact(this.parsedObj.matcher);
+        }
+    }
+}
+function decodeCall(call) {
+    if (!call) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(call);
+        return parsed;
+    }
+    catch (e) {
+        return call;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertion.js","sourceRoot":"","sources":["assertion.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { Match, Matcher } from 'aws-cdk-lib/assertions/lib/helpers-internal';\nimport { CustomResourceHandler } from './base';\nimport { AssertionResult, AssertionRequest } from './types';\n\nexport class AssertionHandler extends CustomResourceHandler<AssertionRequest, AssertionResult> {\n  protected async processEvent(request: AssertionRequest): Promise<AssertionResult | undefined> {\n    let actual = decodeCall(request.actual);\n    const expected = decodeCall(request.expected);\n    let result: AssertionResult;\n    const matcher = new MatchCreator(expected).getMatcher();\n    console.log(`Testing equality between ${JSON.stringify(request.actual)} and ${JSON.stringify(request.expected)}`);\n\n    const matchResult = matcher.test(actual);\n    matchResult.finished();\n    if (matchResult.hasFailed()) {\n      result = {\n        data: JSON.stringify({\n          status: 'fail',\n          message: [\n            ...matchResult.toHumanStrings(),\n            JSON.stringify(matchResult.target, undefined, 2),\n          ].join('\\n'),\n        }),\n      };\n      if (request.failDeployment) {\n        throw new Error(result.data);\n      }\n    } else {\n      result = {\n        data: JSON.stringify({\n          status: 'pass',\n        }),\n      };\n    }\n\n    return result;\n  }\n}\n\n\nclass MatchCreator {\n  private readonly parsedObj: { [key: string]: any };\n  constructor(obj: { [key: string]: any }) {\n    this.parsedObj = {\n      matcher: obj,\n    };\n  }\n\n  /**\n   * Return a Matcher that can be tested against the actual results.\n   * This will convert the encoded matchers into their corresponding\n   * assertions matcher.\n   *\n   * For example:\n   *\n   * ExpectedResult.objectLike({\n   *   Messages: [{\n   *     Body: Match.objectLike({\n   *       Elements: Match.arrayWith([{ Asdf: 3 }]),\n   *     }),\n   *   }],\n   * });\n   *\n   * Will be encoded as:\n   * {\n   *   $ObjectLike: {\n   *     Messages: [{\n   *       Body: {\n   *         $ObjectLike: {\n   *           Elements: {\n   *             $ArrayWith: [{ Asdf: 3 }],\n   *           },\n   *         },\n   *       },\n   *     }],\n   *   },\n   * }\n   *\n   * Which can then be parsed by this function. For each key (recursively)\n   * the parser will check if the value has one of the encoded matchers as a key\n   * and if so, it will set the value as the Matcher. So,\n   *\n   * {\n   *   Body: {\n   *     $ObjectLike: {\n   *       Elements: {\n   *         $ArrayWith: [{ Asdf: 3 }],\n   *       },\n   *     },\n   *   },\n   * }\n   *\n   * Will be converted to\n   * {\n   *   Body: Match.objectLike({\n   *     Elements: Match.arrayWith([{ Asdf: 3 }]),\n   *   }),\n   * }\n   */\n  public getMatcher(): Matcher {\n    try {\n      const final = JSON.parse(JSON.stringify(this.parsedObj), function(_k, v) {\n        const nested = Object.keys(v)[0];\n        switch (nested) {\n          case '$ArrayWith':\n            return Match.arrayWith(v[nested]);\n          case '$ObjectLike':\n            return Match.objectLike(v[nested]);\n          case '$StringLike':\n            return Match.stringLikeRegexp(v[nested]);\n          default:\n            return v;\n        }\n      });\n      if (Matcher.isMatcher(final.matcher)) {\n        return final.matcher;\n      }\n      return Match.exact(final.matcher);\n    } catch {\n      return Match.exact(this.parsedObj.matcher);\n    }\n  }\n}\n\nfunction decodeCall(call?: string) {\n  if (!call) { return undefined; }\n  try {\n    const parsed = JSON.parse(call);\n    return parsed;\n  } catch (e) {\n    return call;\n  }\n}\n"]}

lib/assertions/providers/lambda-handler/index.js

@@ -15,3 +15,3 @@ "use strict";
     if (event.ResourceType.startsWith(types.SDK_RESOURCE_TYPE_PREFIX)) {
-        return new sdk_1.SdkHandler(event, context);
+        return new sdk_1.AwsApiCallHandler(event, context);
     }
@@ -25,2 +25,2 @@ switch (event.ResourceType) {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/assertions/providers/lambda-handler/sdk.d.ts

 import { CustomResourceHandler } from './base';
-import { SdkRequest, SdkResult } from './types';
+import { AwsApiCallRequest, AwsApiCallResult } from './types';
 /**
@@ -12,8 +12,8 @@ * Flattens a nested object
 };
-export declare class SdkHandler extends CustomResourceHandler<SdkRequest, SdkResult | {
+export declare class AwsApiCallHandler extends CustomResourceHandler<AwsApiCallRequest, AwsApiCallResult | {
     [key: string]: string;
 }> {
-    protected processEvent(request: SdkRequest): Promise<SdkResult | {
+    protected processEvent(request: AwsApiCallRequest): Promise<AwsApiCallResult | {
         [key: string]: string;
     } | undefined>;
 }

lib/assertions/providers/lambda-handler/sdk.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SdkHandler = exports.flatten = void 0;
+exports.AwsApiCallHandler = exports.flatten = void 0;
 /* eslint-disable no-console */
 const base_1 = require("./base");
+const utils_1 = require("./utils");
 /**
@@ -24,3 +25,3 @@ * Flattens a nested object
 exports.flatten = flatten;
-class SdkHandler extends base_1.CustomResourceHandler {
+class AwsApiCallHandler extends base_1.CustomResourceHandler {
     async processEvent(request) {
@@ -31,3 +32,3 @@ // eslint-disable-next-line
         const service = new AWS[request.service]();
-        const response = await service[request.api](request.parameters && decode(request.parameters)).promise();
+        const response = await service[request.api](request.parameters && utils_1.decode(request.parameters)).promise();
         console.log(`SDK response received ${JSON.stringify(response)}`);
@@ -44,15 +45,3 @@ delete response.ResponseMetadata;
 }
-exports.SdkHandler = SdkHandler;
-function decode(object) {
-    return JSON.parse(JSON.stringify(object), (_k, v) => {
-        switch (v) {
-            case 'TRUE:BOOLEAN':
-                return true;
-            case 'FALSE:BOOLEAN':
-                return false;
-            default:
-                return v;
-        }
-    });
-}
-//# sourceMappingURL=data:application/json;base64,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
+exports.AwsApiCallHandler = AwsApiCallHandler;
+//# sourceMappingURL=data:application/json;base64,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

lib/assertions/providers/lambda-handler/types.d.ts

@@ -7,3 +7,3 @@ export declare const ASSERT_RESOURCE_TYPE = "Custom::DeployAssert@AssertEquals";
  */
-export interface SdkRequest {
+export interface AwsApiCallRequest {
     /**
@@ -44,3 +44,3 @@ * The AWS service i.e. S3
  */
-export interface SdkResult {
+export interface AwsApiCallResult {
     /**
@@ -58,3 +58,13 @@ * The full api response
      */
-    EQUALS = "equals"
+    EQUALS = "equals",
+    /**
+     * The keys and their values must be present in the target but the target
+     * can be a superset.
+     */
+    OBJECT_LIKE = "objectLike",
+    /**
+     * Matches the specified pattern with the array
+     * The set of elements must be in the same order as would be found
+     */
+    ARRAY_WITH = "arrayWith"
 }
@@ -67,6 +77,2 @@ /**
     /**
-     * The type of assertion to perform
-     */
-    readonly assertionType: AssertionType;
-    /**
      * The expected value to assert
@@ -79,2 +85,12 @@ */
     readonly actual: any;
+    /**
+     * Set this to true if a failed assertion should
+     * result in a CloudFormation deployment failure
+     *
+     * This is only necessary if assertions are being
+     * executed outside of `integ-runner`.
+     *
+     * @default false
+     */
+    readonly failDeployment?: boolean;
 }
@@ -90,5 +106,24 @@ /**
      */
-    readonly data: AssertionResultData;
+    readonly data: string;
+    /**
+     * Whether or not the assertion failed
+     *
+     * @default false
+     */
+    readonly failed?: boolean;
 }
 /**
+ * The status of the assertion
+ */
+export declare enum Status {
+    /**
+     * The assertion passed
+     */
+    PASS = "pass",
+    /**
+     * The assertion failed
+     */
+    FAIL = "fail"
+}
+/**
  * The result of an assertion
@@ -101,3 +136,3 @@ */
      */
-    readonly status: 'pass' | 'fail';
+    readonly status: Status;
     /**
@@ -104,0 +139,0 @@ * Any message returned with the assertion result

lib/assertions/providers/lambda-handler/types.js

@@ -5,3 +5,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertionType = exports.SDK_RESOURCE_TYPE_PREFIX = exports.RESULTS_RESOURCE_TYPE = exports.ASSERT_RESOURCE_TYPE = void 0;
+exports.Status = exports.AssertionType = exports.SDK_RESOURCE_TYPE_PREFIX = exports.RESULTS_RESOURCE_TYPE = exports.ASSERT_RESOURCE_TYPE = void 0;
 exports.ASSERT_RESOURCE_TYPE = 'Custom::DeployAssert@AssertEquals';
@@ -19,3 +19,27 @@ exports.RESULTS_RESOURCE_TYPE = 'Custom::DeployAssert@ResultsCollection';
     AssertionType["EQUALS"] = "equals";
+    /**
+     * The keys and their values must be present in the target but the target
+     * can be a superset.
+     */
+    AssertionType["OBJECT_LIKE"] = "objectLike";
+    /**
+     * Matches the specified pattern with the array
+     * The set of elements must be in the same order as would be found
+     */
+    AssertionType["ARRAY_WITH"] = "arrayWith";
 })(AssertionType = exports.AssertionType || (exports.AssertionType = {}));
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * The status of the assertion
+ */
+var Status;
+(function (Status) {
+    /**
+     * The assertion passed
+     */
+    Status["PASS"] = "pass";
+    /**
+     * The assertion failed
+     */
+    Status["FAIL"] = "fail";
+})(Status = exports.Status || (exports.Status = {}));
+//# sourceMappingURL=data:application/json;base64,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

lib/assertions/providers/provider.d.ts

@@ -1,2 +0,2 @@
-import * as iam from 'aws-cdk-lib/aws-iam';
+import { Reference } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
@@ -10,7 +10,26 @@ /**
 export declare class AssertionsProvider extends Construct {
+    /**
+     * The ARN of the lambda function which can be used
+     * as a serviceToken to a CustomResource
+     */
     readonly serviceToken: string;
-    private readonly grantPrincipal;
+    /**
+     * A reference to the provider Lambda Function
+     * execution Role ARN
+     */
+    readonly handlerRoleArn: Reference;
+    private readonly policies;
+    private readonly handler;
     constructor(scope: Construct, id: string);
+    /**
+     * Encode an object so it can be passed
+     * as custom resource parameters. Custom resources will convert
+     * all input parameters to strings so we encode non-strings here
+     * so we can then decode them correctly in the provider function
+     */
     encode(obj: any): any;
-    addPolicyStatementFromSdkCall(service: string, api: string, resources?: string[]): iam.PolicyStatement;
+    /**
+     * Create a policy statement from a specific api call
+     */
+    addPolicyStatementFromSdkCall(service: string, api: string, resources?: string[]): void;
 }

lib/assertions/providers/provider.js

 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssertionsProvider = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const path = require("path");
-const iam = require("aws-cdk-lib/aws-iam");
-const lambda = require("aws-cdk-lib/aws-lambda");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
@@ -13,2 +13,106 @@ // keep this import separate from other imports to reduce chance for merge conflicts with v2-main
 /**
+ * integ-tests can only depend on '@aws-cdk/core' so
+ * this construct creates a lambda function provider using
+ * only CfnResource
+ */
+class LambdaFunctionProvider extends constructs_1.Construct {
+    constructor(scope, id /*, props?: LambdaFunctionProviderProps*/) {
+        super(scope, id);
+        this.policies = [];
+        const staging = new aws_cdk_lib_1.AssetStaging(this, 'Staging', {
+            sourcePath: path.join(__dirname, 'lambda-handler.bundle'),
+        });
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const asset = stack.synthesizer.addFileAsset({
+            fileName: staging.relativeStagedPath(stack),
+            sourceHash: staging.assetHash,
+            packaging: aws_cdk_lib_1.FileAssetPackaging.ZIP_DIRECTORY,
+        });
+        const role = new aws_cdk_lib_1.CfnResource(this, 'Role', {
+            type: 'AWS::IAM::Role',
+            properties: {
+                AssumeRolePolicyDocument: {
+                    Version: '2012-10-17',
+                    Statement: [{ Action: 'sts:AssumeRole', Effect: 'Allow', Principal: { Service: 'lambda.amazonaws.com' } }],
+                },
+                ManagedPolicyArns: [
+                    { 'Fn::Sub': 'arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole' },
+                ],
+                Policies: [
+                    {
+                        PolicyName: 'Inline',
+                        PolicyDocument: {
+                            Version: '2012-10-17',
+                            Statement: aws_cdk_lib_1.Lazy.list({ produce: () => this.policies }),
+                        },
+                    },
+                ],
+            },
+        });
+        const handler = new aws_cdk_lib_1.CfnResource(this, 'Handler', {
+            type: 'AWS::Lambda::Function',
+            properties: {
+                Runtime: 'nodejs14.x',
+                Code: {
+                    S3Bucket: asset.bucketName,
+                    S3Key: asset.objectKey,
+                },
+                Timeout: aws_cdk_lib_1.Duration.minutes(2).toSeconds(),
+                Handler: 'index.handler',
+                Role: role.getAtt('Arn'),
+            },
+        });
+        this.serviceToken = aws_cdk_lib_1.Token.asString(handler.getAtt('Arn'));
+        this.roleArn = role.getAtt('Arn');
+    }
+    addPolicies(policies) {
+        this.policies.push(...policies);
+    }
+}
+/**
+ * Mimic the singletonfunction construct in '@aws-cdk/aws-lambda'
+ */
+class SingletonFunction extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.policies = [];
+        this.lambdaFunction = this.ensureFunction(props);
+        this.serviceToken = this.lambdaFunction.serviceToken;
+        /**
+         * The policies can be added by different constructs
+         */
+        this.node.addValidation({
+            validate: () => {
+                this.lambdaFunction.addPolicies(this.policies);
+                return [];
+            },
+        });
+    }
+    ensureFunction(props) {
+        const constructName = 'SingletonFunction' + slugify(props.uuid);
+        const existing = aws_cdk_lib_1.Stack.of(this).node.tryFindChild(constructName);
+        if (existing) {
+            return existing;
+        }
+        return new LambdaFunctionProvider(aws_cdk_lib_1.Stack.of(this), constructName);
+    }
+    /**
+     * Create a policy statement from a specific api call
+     */
+    addPolicyStatementFromSdkCall(service, api, resources) {
+        if (SDK_METADATA === undefined) {
+            // eslint-disable-next-line
+            SDK_METADATA = require('./sdk-api-metadata.json');
+        }
+        const srv = service.toLowerCase();
+        const iamService = (SDK_METADATA[srv] && SDK_METADATA[srv].prefix) || srv;
+        const iamAction = api.charAt(0).toUpperCase() + api.slice(1);
+        this.policies.push({
+            Action: [`${iamService}:${iamAction}`],
+            Effect: 'Allow',
+            Resource: resources || ['*'],
+        });
+    }
+}
+/**
  * Represents an assertions provider. The creates a singletone
@@ -22,12 +126,16 @@ * Lambda Function that will create a single function per stack
         super(scope, id);
-        const handler = new lambda.SingletonFunction(this, 'AssertionsProvider', {
-            code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
-            runtime: lambda.Runtime.NODEJS_14_X,
-            handler: 'index.handler',
+        this.policies = [];
+        this.handler = new SingletonFunction(this, 'AssertionsProvider', {
             uuid: '1488541a-7b23-4664-81b6-9b4408076b81',
-            timeout: aws_cdk_lib_1.Duration.minutes(2),
+            policies: aws_cdk_lib_1.Lazy.list({ produce: () => this.policies }),
         });
-        this.grantPrincipal = handler.grantPrincipal;
-        this.serviceToken = handler.functionArn;
+        this.handlerRoleArn = this.handler.lambdaFunction.roleArn;
+        this.serviceToken = this.handler.serviceToken;
     }
+    /**
+     * Encode an object so it can be passed
+     * as custom resource parameters. Custom resources will convert
+     * all input parameters to strings so we encode non-strings here
+     * so we can then decode them correctly in the provider function
+     */
     encode(obj) {
@@ -48,19 +156,15 @@ if (!obj) {
     }
+    /**
+     * Create a policy statement from a specific api call
+     */
     addPolicyStatementFromSdkCall(service, api, resources) {
-        if (SDK_METADATA === undefined) {
-            // eslint-disable-next-line
-            SDK_METADATA = require('./sdk-api-metadata.json');
-        }
-        const srv = service.toLowerCase();
-        const iamService = (SDK_METADATA[srv] && SDK_METADATA[srv].prefix) || srv;
-        const iamAction = api.charAt(0).toUpperCase() + api.slice(1);
-        const statement = new iam.PolicyStatement({
-            actions: [`${iamService}:${iamAction}`],
-            resources: resources || ['*'],
-        });
-        this.grantPrincipal.addToPolicy(statement);
-        return statement;
+        this.handler.addPolicyStatementFromSdkCall(service, api, resources);
     }
 }
 exports.AssertionsProvider = AssertionsProvider;
-//# sourceMappingURL=data:application/json;base64,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
+_a = JSII_RTTI_SYMBOL_1;
+AssertionsProvider[_a] = { fqn: "@aws-cdk/integ-tests-alpha.AssertionsProvider", version: "2.25.0-alpha.0" };
+function slugify(x) {
+    return x.replace(/[^a-zA-Z0-9]/g, '');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["provider.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { Duration, CfnResource, AssetStaging, Stack, FileAssetPackaging, Token, Lazy, Reference } from 'aws-cdk-lib';\n\n// keep this import separate from other imports to reduce chance for merge conflicts with v2-main\n// eslint-disable-next-line no-duplicate-imports, import/order\nimport { Construct } from 'constructs';\n\nlet SDK_METADATA: any = undefined;\n\n\n/**\n * integ-tests can only depend on '@aws-cdk/core' so\n * this construct creates a lambda function provider using\n * only CfnResource\n */\nclass LambdaFunctionProvider extends Construct {\n  /**\n   * The ARN of the lambda function which can be used\n   * as a serviceToken to a CustomResource\n   */\n  public readonly serviceToken: string;\n\n  /**\n   * A Reference to the provider lambda exeuction role ARN\n   */\n  public readonly roleArn: Reference;\n\n  private readonly policies: any[] = [];\n\n  constructor(scope: Construct, id: string/*, props?: LambdaFunctionProviderProps*/) {\n    super(scope, id);\n\n    const staging = new AssetStaging(this, 'Staging', {\n      sourcePath: path.join(__dirname, 'lambda-handler.bundle'),\n    });\n\n    const stack = Stack.of(this);\n    const asset = stack.synthesizer.addFileAsset({\n      fileName: staging.relativeStagedPath(stack),\n      sourceHash: staging.assetHash,\n      packaging: FileAssetPackaging.ZIP_DIRECTORY,\n    });\n\n    const role = new CfnResource(this, 'Role', {\n      type: 'AWS::IAM::Role',\n      properties: {\n        AssumeRolePolicyDocument: {\n          Version: '2012-10-17',\n          Statement: [{ Action: 'sts:AssumeRole', Effect: 'Allow', Principal: { Service: 'lambda.amazonaws.com' } }],\n        },\n        ManagedPolicyArns: [\n          { 'Fn::Sub': 'arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole' },\n        ],\n        Policies: [\n          {\n            PolicyName: 'Inline',\n            PolicyDocument: {\n              Version: '2012-10-17',\n              Statement: Lazy.list({ produce: () => this.policies }),\n            },\n          },\n        ],\n      },\n    });\n\n    const handler = new CfnResource(this, 'Handler', {\n      type: 'AWS::Lambda::Function',\n      properties: {\n        Runtime: 'nodejs14.x',\n        Code: {\n          S3Bucket: asset.bucketName,\n          S3Key: asset.objectKey,\n        },\n        Timeout: Duration.minutes(2).toSeconds(),\n        Handler: 'index.handler',\n        Role: role.getAtt('Arn'),\n      },\n    });\n\n    this.serviceToken = Token.asString(handler.getAtt('Arn'));\n    this.roleArn = role.getAtt('Arn');\n  }\n\n  public addPolicies(policies: any[]): void {\n    this.policies.push(...policies);\n  }\n\n}\n\ninterface SingletonFunctionProps {\n  /**\n   * A unique identifier to identify this lambda\n   *\n   * The identifier should be unique across all custom resource providers.\n   * We recommend generating a UUID per provider.\n   */\n  readonly uuid: string;\n\n  /**\n   * A list of IAM policies to add to the lambdaFunction\n   * execution role\n   */\n  readonly policies: any[];\n}\n\n/**\n * Mimic the singletonfunction construct in '@aws-cdk/aws-lambda'\n */\nclass SingletonFunction extends Construct {\n  public readonly serviceToken: string;\n\n  public readonly lambdaFunction: LambdaFunctionProvider;\n  private readonly policies: any[] = [];\n  constructor(scope: Construct, id: string, props: SingletonFunctionProps) {\n    super(scope, id);\n    this.lambdaFunction = this.ensureFunction(props);\n    this.serviceToken = this.lambdaFunction.serviceToken;\n\n    /**\n     * The policies can be added by different constructs\n     */\n    this.node.addValidation({\n      validate: () => {\n        this.lambdaFunction.addPolicies(this.policies);\n        return [];\n      },\n    });\n  }\n\n  private ensureFunction(props: SingletonFunctionProps): LambdaFunctionProvider {\n    const constructName = 'SingletonFunction' + slugify(props.uuid);\n    const existing = Stack.of(this).node.tryFindChild(constructName);\n    if (existing) {\n      return existing as LambdaFunctionProvider;\n    }\n\n    return new LambdaFunctionProvider(Stack.of(this), constructName);\n  }\n\n  /**\n   * Create a policy statement from a specific api call\n   */\n  public addPolicyStatementFromSdkCall(service: string, api: string, resources?: string[]): void {\n    if (SDK_METADATA === undefined) {\n      // eslint-disable-next-line\n      SDK_METADATA = require('./sdk-api-metadata.json');\n    }\n    const srv = service.toLowerCase();\n    const iamService = (SDK_METADATA[srv] && SDK_METADATA[srv].prefix) || srv;\n    const iamAction = api.charAt(0).toUpperCase() + api.slice(1);\n    this.policies.push({\n      Action: [`${iamService}:${iamAction}`],\n      Effect: 'Allow',\n      Resource: resources || ['*'],\n    });\n  }\n\n}\n\n/**\n * Represents an assertions provider. The creates a singletone\n * Lambda Function that will create a single function per stack\n * that serves as the custom resource provider for the various\n * assertion providers\n */\nexport class AssertionsProvider extends Construct {\n  /**\n   * The ARN of the lambda function which can be used\n   * as a serviceToken to a CustomResource\n   */\n  public readonly serviceToken: string;\n  /**\n   * A reference to the provider Lambda Function\n   * execution Role ARN\n   */\n  public readonly handlerRoleArn: Reference;\n\n  private readonly policies: any[] = [];\n  private readonly handler: SingletonFunction;\n\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n\n    this.handler = new SingletonFunction(this, 'AssertionsProvider', {\n      uuid: '1488541a-7b23-4664-81b6-9b4408076b81',\n      policies: Lazy.list({ produce: () => this.policies }),\n    });\n\n    this.handlerRoleArn = this.handler.lambdaFunction.roleArn;\n\n    this.serviceToken = this.handler.serviceToken;\n  }\n\n  /**\n   * Encode an object so it can be passed\n   * as custom resource parameters. Custom resources will convert\n   * all input parameters to strings so we encode non-strings here\n   * so we can then decode them correctly in the provider function\n   */\n  public encode(obj: any): any {\n    if (!obj) {\n      return obj;\n    }\n    return JSON.parse(JSON.stringify(obj), (_k, v) => {\n      switch (v) {\n        case true:\n          return 'TRUE:BOOLEAN';\n        case false:\n          return 'FALSE:BOOLEAN';\n        default:\n          return v;\n      }\n    });\n  }\n\n  /**\n   * Create a policy statement from a specific api call\n   */\n  public addPolicyStatementFromSdkCall(service: string, api: string, resources?: string[]): void {\n    this.handler.addPolicyStatementFromSdkCall(service, api, resources);\n  }\n}\n\nfunction slugify(x: string): string {\n  return x.replace(/[^a-zA-Z0-9]/g, '');\n}\n"]}

lib/assertions/sdk.d.ts

 import { Reference } from 'aws-cdk-lib';
-import { IAssertion } from './deploy-assert';
+import { ExpectedResult } from './common';
+import { AssertionsProvider } from './providers';
 import { Construct } from 'constructs';
@@ -7,3 +8,3 @@ /**
  */
-export interface SdkQueryOptions {
+export interface AwsApiCallOptions {
     /**
@@ -19,2 +20,4 @@ * The AWS service, i.e. S3
      * Any parameters to pass to the api call
+     *
+     * @default - no parameters
      */
@@ -26,8 +29,14 @@ readonly parameters?: any;
  */
-export interface SdkQueryProps extends SdkQueryOptions {
+export interface AwsApiCallProps extends AwsApiCallOptions {
 }
-export declare class SdkQuery extends Construct {
+/**
+ * Construct that creates a custom resource that will perform
+ * a query using the AWS SDK
+ */
+export declare class AwsApiCall extends Construct {
     private readonly sdkCallResource;
     private flattenResponse;
-    constructor(scope: Construct, id: string, props: SdkQueryProps);
+    private readonly name;
+    protected provider: AssertionsProvider;
+    constructor(scope: Construct, id: string, props: AwsApiCallProps);
     /**
@@ -53,6 +62,118 @@ * Returns the value of an attribute of the custom resource of an arbitrary
     /**
-     * Creates an assertion custom resource that will assert that the response
-     * from the SDKQuery equals the 'expected' value
+     * Assert that the ExpectedResult is equal
+     * to the result of the AwsApiCall
+     *
+     * @example
+     * declare const assert: DeployAssert;
+     * const invoke = new LambdaInvokeFunction(assert, 'Invoke', {
+     *   functionName: 'my-func',
+     * });
+     * invoke.assert(ExpectedResult.objectLike({ Payload: 'OK' }));
      */
-    assertEqual(expected: any, actualAttr?: string): IAssertion;
+    assert(expected: ExpectedResult): void;
+    /**
+     * Assert that the ExpectedResult is equal
+     * to the result of the AwsApiCall at the given path.
+     *
+     * For example the SQS.receiveMessage api response would look
+     * like:
+     *
+     * If you wanted to assert the value of `Body` you could do
+     *
+     * @example
+     * const actual = {
+     *   Messages: [{
+     *     MessageId: '',
+     *     ReceiptHandle: '',
+     *     MD5OfBody: '',
+     *     Body: 'hello',
+     *     Attributes: {},
+     *     MD5OfMessageAttributes: {},
+     *     MessageAttributes: {}
+     *   }]
+     * };
+     *
+     *
+     * declare const assert: DeployAssert;
+     * const message = new AwsApiCall(assert, 'ReceiveMessage', {
+     *   service:  'SQS',
+     *   api: 'receiveMessage'
+     * });
+     *
+     * message.assertAtPath('Messages.0.Body', ExpectedResult.stringLikeRegexp('hello'));
+     */
+    assertAtPath(path: string, expected: ExpectedResult): void;
 }
+/**
+ * Set to Tail to include the execution log in the response.
+ * Applies to synchronously invoked functions only.
+ */
+export declare enum LogType {
+    /**
+     * The log messages are not returned in the response
+     */
+    NONE = "None",
+    /**
+     * The log messages are returned in the response
+     */
+    TAIL = "Tail"
+}
+/**
+ * The type of invocation. Default is REQUEST_RESPONE
+ */
+export declare enum InvocationType {
+    /**
+     * Invoke the function asynchronously.
+     * Send events that fail multiple times to the function's
+     * dead-letter queue (if it's configured).
+     * The API response only includes a status code.
+     */
+    EVENT = "Event",
+    /**
+     * Invoke the function synchronously.
+     * Keep the connection open until the function returns a response or times out.
+     * The API response includes the function response and additional data.
+     */
+    REQUEST_RESPONE = "RequestResponse",
+    /**
+     * Validate parameter values and verify that the user
+     * or role has permission to invoke the function.
+     */
+    DRY_RUN = "DryRun"
+}
+/**
+ * Options to pass to the Lambda invokeFunction API call
+ */
+export interface LambdaInvokeFunctionProps {
+    /**
+     * The name of the function to invoke
+     */
+    readonly functionName: string;
+    /**
+     * The type of invocation to use
+     *
+     * @default InvocationType.REQUEST_RESPONE
+     */
+    readonly invocationType?: InvocationType;
+    /**
+     * Whether to return the logs as part of the response
+     *
+     * @default LogType.NONE
+     */
+    readonly logType?: LogType;
+    /**
+     * Payload to send as part of the invoke
+     *
+     * @default - no payload
+     */
+    readonly payload?: string;
+}
+/**
+ * An AWS Lambda Invoke function API call.
+ * Use this istead of the generic AwsApiCall in order to
+ * invoke a lambda function. This will automatically create
+ * the correct permissions to invoke the function
+ */
+export declare class LambdaInvokeFunction extends AwsApiCall {
+    constructor(scope: Construct, id: string, props: LambdaInvokeFunctionProps);
+}

lib/assertions/sdk.js

 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SdkQuery = void 0;
+exports.LambdaInvokeFunction = exports.InvocationType = exports.LogType = exports.AwsApiCall = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const assertions_1 = require("./assertions");
-const hash_1 = require("./private/hash");
+const common_1 = require("./common");
 const providers_1 = require("./providers");
@@ -11,20 +14,35 @@ // keep this import separate from other imports to reduce chance for merge conflicts with v2-main
 const constructs_1 = require("constructs");
-class SdkQuery extends constructs_1.Construct {
+/**
+ * Construct that creates a custom resource that will perform
+ * a query using the AWS SDK
+ */
+class AwsApiCall extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
         this.flattenResponse = 'false';
-        const provider = new providers_1.AssertionsProvider(this, 'SdkProvider');
-        provider.addPolicyStatementFromSdkCall(props.service, props.api);
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_AwsApiCallProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.constructor);
+            }
+            throw error;
+        }
+        this.provider = new providers_1.AssertionsProvider(this, 'SdkProvider');
+        this.provider.addPolicyStatementFromSdkCall(props.service, props.api);
+        this.name = `${props.service}${props.api}`;
         this.sdkCallResource = new aws_cdk_lib_1.CustomResource(this, 'Default', {
-            serviceToken: provider.serviceToken,
+            serviceToken: this.provider.serviceToken,
             properties: {
                 service: props.service,
                 api: props.api,
-                parameters: provider.encode(props.parameters),
+                parameters: this.provider.encode(props.parameters),
                 flattenResponse: aws_cdk_lib_1.Lazy.string({ produce: () => this.flattenResponse }),
+                salt: Date.now().toString(),
             },
-            resourceType: `${providers_1.SDK_RESOURCE_TYPE_PREFIX}${props.service}${props.api}`,
+            resourceType: `${providers_1.SDK_RESOURCE_TYPE_PREFIX}${this.name}`,
         });
         // Needed so that all the policies set up by the provider should be available before the custom resource is provisioned.
-        this.sdkCallResource.node.addDependency(provider);
+        this.sdkCallResource.node.addDependency(this.provider);
     }
@@ -57,20 +75,166 @@ /**
     /**
-     * Creates an assertion custom resource that will assert that the response
-     * from the SDKQuery equals the 'expected' value
+     * Assert that the ExpectedResult is equal
+     * to the result of the AwsApiCall
+     *
+     * @example
+     * declare const assert: DeployAssert;
+     * const invoke = new LambdaInvokeFunction(assert, 'Invoke', {
+     *   functionName: 'my-func',
+     * });
+     * invoke.assert(ExpectedResult.objectLike({ Payload: 'OK' }));
      */
-    assertEqual(expected, actualAttr) {
-        const hash = hash_1.md5hash(expected);
-        let inputResourceAtt = 'apiCallResponse';
-        if (actualAttr) {
-            this.flattenResponse = 'true';
-            inputResourceAtt = `apiCallResponse.${actualAttr}`;
+    assert(expected) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_ExpectedResult(expected);
         }
-        return new assertions_1.EqualsAssertion(this, `AssertEquals${hash}`, {
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.assert);
+            }
+            throw error;
+        }
+        new assertions_1.EqualsAssertion(this, `AssertEquals${this.name}`, {
             expected,
-            inputResource: this.sdkCallResource,
-            inputResourceAtt,
+            actual: common_1.ActualResult.fromCustomResource(this.sdkCallResource, 'apiCallResponse'),
         });
     }
+    /**
+     * Assert that the ExpectedResult is equal
+     * to the result of the AwsApiCall at the given path.
+     *
+     * For example the SQS.receiveMessage api response would look
+     * like:
+     *
+     * If you wanted to assert the value of `Body` you could do
+     *
+     * @example
+     * const actual = {
+     *   Messages: [{
+     *     MessageId: '',
+     *     ReceiptHandle: '',
+     *     MD5OfBody: '',
+     *     Body: 'hello',
+     *     Attributes: {},
+     *     MD5OfMessageAttributes: {},
+     *     MessageAttributes: {}
+     *   }]
+     * };
+     *
+     *
+     * declare const assert: DeployAssert;
+     * const message = new AwsApiCall(assert, 'ReceiveMessage', {
+     *   service:  'SQS',
+     *   api: 'receiveMessage'
+     * });
+     *
+     * message.assertAtPath('Messages.0.Body', ExpectedResult.stringLikeRegexp('hello'));
+     */
+    assertAtPath(path, expected) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_ExpectedResult(expected);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.assertAtPath);
+            }
+            throw error;
+        }
+        new assertions_1.EqualsAssertion(this, `AssertEquals${this.name}`, {
+            expected,
+            actual: common_1.ActualResult.fromAwsApiCall(this, path),
+        });
+    }
 }
-exports.SdkQuery = SdkQuery;
-//# sourceMappingURL=data:application/json;base64,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
+exports.AwsApiCall = AwsApiCall;
+_a = JSII_RTTI_SYMBOL_1;
+AwsApiCall[_a] = { fqn: "@aws-cdk/integ-tests-alpha.AwsApiCall", version: "2.25.0-alpha.0" };
+/**
+ * Set to Tail to include the execution log in the response.
+ * Applies to synchronously invoked functions only.
+ */
+var LogType;
+(function (LogType) {
+    /**
+     * The log messages are not returned in the response
+     */
+    LogType["NONE"] = "None";
+    /**
+     * The log messages are returned in the response
+     */
+    LogType["TAIL"] = "Tail";
+})(LogType = exports.LogType || (exports.LogType = {}));
+/**
+ * The type of invocation. Default is REQUEST_RESPONE
+ */
+var InvocationType;
+(function (InvocationType) {
+    /**
+     * Invoke the function asynchronously.
+     * Send events that fail multiple times to the function's
+     * dead-letter queue (if it's configured).
+     * The API response only includes a status code.
+     */
+    InvocationType["EVENT"] = "Event";
+    /**
+     * Invoke the function synchronously.
+     * Keep the connection open until the function returns a response or times out.
+     * The API response includes the function response and additional data.
+     */
+    InvocationType["REQUEST_RESPONE"] = "RequestResponse";
+    /**
+     * Validate parameter values and verify that the user
+     * or role has permission to invoke the function.
+     */
+    InvocationType["DRY_RUN"] = "DryRun";
+})(InvocationType = exports.InvocationType || (exports.InvocationType = {}));
+/**
+ * An AWS Lambda Invoke function API call.
+ * Use this istead of the generic AwsApiCall in order to
+ * invoke a lambda function. This will automatically create
+ * the correct permissions to invoke the function
+ */
+class LambdaInvokeFunction extends AwsApiCall {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            api: 'invoke',
+            service: 'Lambda',
+            parameters: {
+                FunctionName: props.functionName,
+                InvocationType: props.invocationType,
+                LogType: props.logType,
+                Payload: props.payload,
+            },
+        });
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_LambdaInvokeFunctionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.constructor);
+            }
+            throw error;
+        }
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        // need to give the assertion lambda permission to invoke
+        new aws_cdk_lib_1.CfnResource(this, 'Invoke', {
+            type: 'AWS::Lambda::Permission',
+            properties: {
+                Action: 'lambda:InvokeFunction',
+                FunctionName: props.functionName,
+                Principal: this.provider.handlerRoleArn,
+            },
+        });
+        // the api call is 'invoke', but the permission is 'invokeFunction'
+        // so need to handle it specially
+        this.provider.addPolicyStatementFromSdkCall('Lambda', 'invokeFunction', [stack.formatArn({
+                service: 'lambda',
+                resource: 'function',
+                arnFormat: aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME,
+                resourceName: props.functionName,
+            })]);
+    }
+}
+exports.LambdaInvokeFunction = LambdaInvokeFunction;
+_b = JSII_RTTI_SYMBOL_1;
+LambdaInvokeFunction[_b] = { fqn: "@aws-cdk/integ-tests-alpha.LambdaInvokeFunction", version: "2.25.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk.js","sourceRoot":"","sources":["sdk.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA6F;AAC7F,6CAA+C;AAC/C,qCAAwD;AACxD,2CAA2E;AAE3E,iGAAiG;AACjG,8DAA8D;AAC9D,2CAAuC;AA6BvC;;;GAGG;AACH,MAAa,UAAW,SAAQ,sBAAS;IAOvC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAsB;QAC9D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QANX,oBAAe,GAAW,OAAO,CAAC;;;;;;;;;;QAQxC,IAAI,CAAC,QAAQ,GAAG,IAAI,8BAAkB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,GAAG,GAAG,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;QAE3C,IAAI,CAAC,eAAe,GAAG,IAAI,4BAAc,CAAC,IAAI,EAAE,SAAS,EAAE;YACzD,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY;YACxC,UAAU,EAAE;gBACV,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,GAAG,EAAE,KAAK,CAAC,GAAG;gBACd,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC;gBAClD,eAAe,EAAE,kBAAI,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;aAC5B;YACD,YAAY,EAAE,GAAG,oCAAwB,GAAG,IAAI,CAAC,IAAI,EAAE;SACxD,CAAC,CAAC;QAEH,wHAAwH;QACxH,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACxD;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,aAAqB;QACjC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;QAC9B,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,mBAAmB,aAAa,EAAE,CAAC,CAAC;KACxE;IAED;;;;;;;OAOG;IACI,YAAY,CAAC,aAAqB;QACvC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;QAC9B,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,mBAAmB,aAAa,EAAE,CAAC,CAAC;KAC9E;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAwB;;;;;;;;;;QACpC,IAAI,4BAAe,CAAC,IAAI,EAAE,eAAe,IAAI,CAAC,IAAI,EAAE,EAAE;YACpD,QAAQ;YACR,MAAM,EAAE,qBAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC;SACjF,CAAC,CAAC;KACJ;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACI,YAAY,CAAC,IAAY,EAAE,QAAwB;;;;;;;;;;QACxD,IAAI,4BAAe,CAAC,IAAI,EAAE,eAAe,IAAI,CAAC,IAAI,EAAE,EAAE;YACpD,QAAQ;YACR,MAAM,EAAE,qBAAY,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC;SAChD,CAAC,CAAC;KACJ;;AA/GH,gCAgHC;;;AAED;;;GAGG;AACH,IAAY,OAUX;AAVD,WAAY,OAAO;IACjB;;OAEG;IACH,wBAAa,CAAA;IAEb;;OAEG;IACH,wBAAa,CAAA;AACf,CAAC,EAVW,OAAO,GAAP,eAAO,KAAP,eAAO,QAUlB;AAED;;GAEG;AACH,IAAY,cAqBX;AArBD,WAAY,cAAc;IACxB;;;;;OAKG;IACH,iCAAe,CAAA;IAEf;;;;OAIG;IACH,qDAAmC,CAAA;IAEnC;;;OAGG;IACH,oCAAkB,CAAA;AACpB,CAAC,EArBW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAqBzB;AAiCD;;;;;GAKG;AACH,MAAa,oBAAqB,SAAQ,UAAU;IAClD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAgC;QACxE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,GAAG,EAAE,QAAQ;YACb,OAAO,EAAE,QAAQ;YACjB,UAAU,EAAE;gBACV,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,cAAc,EAAE,KAAK,CAAC,cAAc;gBACpC,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB;SACF,CAAC,CAAC;;;;;;;;;;QAEH,MAAM,KAAK,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAC7B,yDAAyD;QACzD,IAAI,yBAAW,CAAC,IAAI,EAAE,QAAQ,EAAE;YAC9B,IAAI,EAAE,yBAAyB;YAC/B,UAAU,EAAE;gBACV,MAAM,EAAE,uBAAuB;gBAC/B,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc;aACxC;SACF,CAAC,CAAC;QAEH,mEAAmE;QACnE,iCAAiC;QACjC,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAAC,QAAQ,EAAE,gBAAgB,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;gBACvF,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,UAAU;gBACpB,SAAS,EAAE,uBAAS,CAAC,mBAAmB;gBACxC,YAAY,EAAE,KAAK,CAAC,YAAY;aACjC,CAAC,CAAC,CAAC,CAAC;KACN;;AAhCH,oDAiCC","sourcesContent":["import { CustomResource, Reference, Lazy, CfnResource, Stack, ArnFormat } from 'aws-cdk-lib';\nimport { EqualsAssertion } from './assertions';\nimport { ExpectedResult, ActualResult } from './common';\nimport { AssertionsProvider, SDK_RESOURCE_TYPE_PREFIX } from './providers';\n\n// keep this import separate from other imports to reduce chance for merge conflicts with v2-main\n// eslint-disable-next-line no-duplicate-imports, import/order\nimport { Construct } from 'constructs';\n\n/**\n * Options to perform an AWS JavaScript V2 API call\n */\nexport interface AwsApiCallOptions {\n  /**\n   * The AWS service, i.e. S3\n   */\n  readonly service: string;\n\n  /**\n   * The api call to make, i.e. getBucketLifecycle\n   */\n  readonly api: string;\n\n  /**\n   * Any parameters to pass to the api call\n   *\n   * @default - no parameters\n   */\n  readonly parameters?: any;\n}\n\n/**\n * Options for creating an SDKQuery provider\n */\nexport interface AwsApiCallProps extends AwsApiCallOptions {}\n\n/**\n * Construct that creates a custom resource that will perform\n * a query using the AWS SDK\n */\nexport class AwsApiCall extends Construct {\n  private readonly sdkCallResource: CustomResource;\n  private flattenResponse: string = 'false';\n  private readonly name: string;\n\n  protected provider: AssertionsProvider;\n\n  constructor(scope: Construct, id: string, props: AwsApiCallProps) {\n    super(scope, id);\n\n    this.provider = new AssertionsProvider(this, 'SdkProvider');\n    this.provider.addPolicyStatementFromSdkCall(props.service, props.api);\n    this.name = `${props.service}${props.api}`;\n\n    this.sdkCallResource = new CustomResource(this, 'Default', {\n      serviceToken: this.provider.serviceToken,\n      properties: {\n        service: props.service,\n        api: props.api,\n        parameters: this.provider.encode(props.parameters),\n        flattenResponse: Lazy.string({ produce: () => this.flattenResponse }),\n        salt: Date.now().toString(),\n      },\n      resourceType: `${SDK_RESOURCE_TYPE_PREFIX}${this.name}`,\n    });\n\n    // Needed so that all the policies set up by the provider should be available before the custom resource is provisioned.\n    this.sdkCallResource.node.addDependency(this.provider);\n  }\n\n  /**\n   * Returns the value of an attribute of the custom resource of an arbitrary\n   * type. Attributes are returned from the custom resource provider through the\n   * `Data` map where the key is the attribute name.\n   *\n   * @param attributeName the name of the attribute\n   * @returns a token for `Fn::GetAtt`. Use `Token.asXxx` to encode the returned `Reference` as a specific type or\n   * use the convenience `getAttString` for string attributes.\n   */\n  public getAtt(attributeName: string): Reference {\n    this.flattenResponse = 'true';\n    return this.sdkCallResource.getAtt(`apiCallResponse.${attributeName}`);\n  }\n\n  /**\n   * Returns the value of an attribute of the custom resource of type string.\n   * Attributes are returned from the custom resource provider through the\n   * `Data` map where the key is the attribute name.\n   *\n   * @param attributeName the name of the attribute\n   * @returns a token for `Fn::GetAtt` encoded as a string.\n   */\n  public getAttString(attributeName: string): string {\n    this.flattenResponse = 'true';\n    return this.sdkCallResource.getAttString(`apiCallResponse.${attributeName}`);\n  }\n\n  /**\n   * Assert that the ExpectedResult is equal\n   * to the result of the AwsApiCall\n   *\n   * @example\n   * declare const assert: DeployAssert;\n   * const invoke = new LambdaInvokeFunction(assert, 'Invoke', {\n   *   functionName: 'my-func',\n   * });\n   * invoke.assert(ExpectedResult.objectLike({ Payload: 'OK' }));\n   */\n  public assert(expected: ExpectedResult): void {\n    new EqualsAssertion(this, `AssertEquals${this.name}`, {\n      expected,\n      actual: ActualResult.fromCustomResource(this.sdkCallResource, 'apiCallResponse'),\n    });\n  }\n\n  /**\n   * Assert that the ExpectedResult is equal\n   * to the result of the AwsApiCall at the given path.\n   *\n   * For example the SQS.receiveMessage api response would look\n   * like:\n   *\n   * If you wanted to assert the value of `Body` you could do\n   *\n   * @example\n   * const actual = {\n   *   Messages: [{\n   *     MessageId: '',\n   *     ReceiptHandle: '',\n   *     MD5OfBody: '',\n   *     Body: 'hello',\n   *     Attributes: {},\n   *     MD5OfMessageAttributes: {},\n   *     MessageAttributes: {}\n   *   }]\n   * };\n   *\n   *\n   * declare const assert: DeployAssert;\n   * const message = new AwsApiCall(assert, 'ReceiveMessage', {\n   *   service:  'SQS',\n   *   api: 'receiveMessage'\n   * });\n   *\n   * message.assertAtPath('Messages.0.Body', ExpectedResult.stringLikeRegexp('hello'));\n   */\n  public assertAtPath(path: string, expected: ExpectedResult): void {\n    new EqualsAssertion(this, `AssertEquals${this.name}`, {\n      expected,\n      actual: ActualResult.fromAwsApiCall(this, path),\n    });\n  }\n}\n\n/**\n * Set to Tail to include the execution log in the response.\n * Applies to synchronously invoked functions only.\n */\nexport enum LogType {\n  /**\n   * The log messages are not returned in the response\n   */\n  NONE = 'None',\n\n  /**\n   * The log messages are returned in the response\n   */\n  TAIL = 'Tail',\n}\n\n/**\n * The type of invocation. Default is REQUEST_RESPONE\n */\nexport enum InvocationType {\n  /**\n   * Invoke the function asynchronously.\n   * Send events that fail multiple times to the function's\n   * dead-letter queue (if it's configured).\n   * The API response only includes a status code.\n   */\n  EVENT = 'Event',\n\n  /**\n   * Invoke the function synchronously.\n   * Keep the connection open until the function returns a response or times out.\n   * The API response includes the function response and additional data.\n   */\n  REQUEST_RESPONE = 'RequestResponse',\n\n  /**\n   * Validate parameter values and verify that the user\n   * or role has permission to invoke the function.\n   */\n  DRY_RUN = 'DryRun',\n}\n\n/**\n * Options to pass to the Lambda invokeFunction API call\n */\nexport interface LambdaInvokeFunctionProps {\n  /**\n   * The name of the function to invoke\n   */\n  readonly functionName: string;\n\n  /**\n   * The type of invocation to use\n   *\n   * @default InvocationType.REQUEST_RESPONE\n   */\n  readonly invocationType?: InvocationType;\n\n  /**\n   * Whether to return the logs as part of the response\n   *\n   * @default LogType.NONE\n   */\n  readonly logType?: LogType;\n\n  /**\n   * Payload to send as part of the invoke\n   *\n   * @default - no payload\n   */\n  readonly payload?: string;\n}\n\n/**\n * An AWS Lambda Invoke function API call.\n * Use this istead of the generic AwsApiCall in order to\n * invoke a lambda function. This will automatically create\n * the correct permissions to invoke the function\n */\nexport class LambdaInvokeFunction extends AwsApiCall {\n  constructor(scope: Construct, id: string, props: LambdaInvokeFunctionProps) {\n    super(scope, id, {\n      api: 'invoke',\n      service: 'Lambda',\n      parameters: {\n        FunctionName: props.functionName,\n        InvocationType: props.invocationType,\n        LogType: props.logType,\n        Payload: props.payload,\n      },\n    });\n\n    const stack = Stack.of(this);\n    // need to give the assertion lambda permission to invoke\n    new CfnResource(this, 'Invoke', {\n      type: 'AWS::Lambda::Permission',\n      properties: {\n        Action: 'lambda:InvokeFunction',\n        FunctionName: props.functionName,\n        Principal: this.provider.handlerRoleArn,\n      },\n    });\n\n    // the api call is 'invoke', but the permission is 'invokeFunction'\n    // so need to handle it specially\n    this.provider.addPolicyStatementFromSdkCall('Lambda', 'invokeFunction', [stack.formatArn({\n      service: 'lambda',\n      resource: 'function',\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      resourceName: props.functionName,\n    })]);\n  }\n}\n\n"]}

lib/index.d.ts

 export * from './test-case';
+export * from './assertions';

lib/index.js

@@ -14,2 +14,3 @@ "use strict";
 __exportStar(require("./test-case"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3Rlc3QtY2FzZSc7XG4iXX0=
+__exportStar(require("./assertions"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBNEI7QUFDNUIsK0NBQTZCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90ZXN0LWNhc2UnO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NlcnRpb25zJztcbiJdfQ==

lib/test-case.d.ts

 import { IntegManifest, TestOptions } from 'aws-cdk-lib/cloud-assembly-schema';
-import { Stack } from 'aws-cdk-lib';
+import { Stack, StackProps } from 'aws-cdk-lib';
+import { DeployAssert } from './assertions';
 import { Construct } from 'constructs';
@@ -16,6 +17,12 @@ /**
  * apply to all stacks under this case.
+ *
+ * It is recommended that you use the IntegTest construct since that will create
+ * a default IntegTestCase
  */
 export declare class IntegTestCase extends Construct {
-    private readonly id;
     private readonly props;
+    /**
+     * Make assertions on resources in this test case
+     */
+    readonly assert: DeployAssert;
     constructor(scope: Construct, id: string, props: IntegTestCaseProps);
@@ -27,11 +34,41 @@ /**
     get manifest(): IntegManifest;
+    private toTestCase;
 }
 /**
+ * Properties of an integration test case stack
+ */
+export interface IntegTestCaseStackProps extends TestOptions, StackProps {
+}
+/**
+ * An integration test case stack. Allows the definition of test properties
+ * that should apply to this stack.
+ *
+ * This should be used if there are multiple stacks in the integration test
+ * and it is necessary to specify different test case option for each. Otherwise
+ * normal stacks should be added to IntegTest
+ */
+export declare class IntegTestCaseStack extends Stack {
+    /**
+     * Returns whether the construct is a IntegTestCaseStack
+     */
+    static isIntegTestCaseStack(x: any): x is IntegTestCaseStack;
+    /**
+     * Make assertions on resources in this test case
+     */
+    readonly assert: DeployAssert;
+    /**
+     * The underlying IntegTestCase that is created
+     * @internal
+     */
+    readonly _testCase: IntegTestCase;
+    constructor(scope: Construct, id: string, props?: IntegTestCaseStackProps);
+}
+/**
  * Integration test properties
  */
-export interface IntegTestProps {
+export interface IntegTestProps extends TestOptions {
     /**
      * List of test cases that make up this test
      */
-    readonly testCases: IntegTestCase[];
+    readonly testCases: Stack[];
 }
@@ -43,5 +80,8 @@ /**
 export declare class IntegTest extends Construct {
-    private readonly props;
+    /**
+     * Make assertions on resources in this test case
+     */
+    readonly assert: DeployAssert;
+    private readonly testCases;
     constructor(scope: Construct, id: string, props: IntegTestProps);
-    protected onPrepare(): void;
 }

lib/test-case.js

 "use strict";
-var _a, _b;
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegTest = exports.IntegTestCase = void 0;
+exports.IntegTest = exports.IntegTestCaseStack = exports.IntegTestCase = void 0;
 const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
@@ -9,3 +9,5 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("./assertions");
 const manifest_synthesizer_1 = require("./manifest-synthesizer");
+const TEST_CASE_STACK_SYMBOL = Symbol.for('@aws-cdk/integ-tests.IntegTestCaseStack');
 // keep this import separate from other imports to reduce chance for merge conflicts with v2-main
@@ -17,2 +19,5 @@ // eslint-disable-next-line no-duplicate-imports, import/order
  * apply to all stacks under this case.
+ *
+ * It is recommended that you use the IntegTest construct since that will create
+ * a default IntegTestCase
  */
@@ -22,3 +27,2 @@ class IntegTestCase extends constructs_1.Construct {
         super(scope, id);
-        this.id = id;
         this.props = props;
@@ -34,2 +38,3 @@ try {
         }
+        this.assert = new assertions_1.DeployAssert(this);
     }
@@ -43,10 +48,55 @@ /**
             version: cloud_assembly_schema_1.Manifest.version(),
-            testCases: { [this.id]: toTestCase(this.props) },
+            testCases: { [this.node.path]: this.toTestCase(this.props) },
         };
     }
+    toTestCase(props) {
+        return {
+            ...props,
+            assertionStack: aws_cdk_lib_1.Stack.of(this.assert).artifactId,
+            stacks: props.stacks.map(s => s.artifactId),
+        };
+    }
 }
 exports.IntegTestCase = IntegTestCase;
 _a = JSII_RTTI_SYMBOL_1;
-IntegTestCase[_a] = { fqn: "@aws-cdk/integ-tests-alpha.IntegTestCase", version: "2.24.1-alpha.0" };
+IntegTestCase[_a] = { fqn: "@aws-cdk/integ-tests-alpha.IntegTestCase", version: "2.25.0-alpha.0" };
 /**
+ * An integration test case stack. Allows the definition of test properties
+ * that should apply to this stack.
+ *
+ * This should be used if there are multiple stacks in the integration test
+ * and it is necessary to specify different test case option for each. Otherwise
+ * normal stacks should be added to IntegTest
+ */
+class IntegTestCaseStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        try {
+            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_IntegTestCaseStackProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.constructor);
+            }
+            throw error;
+        }
+        Object.defineProperty(this, TEST_CASE_STACK_SYMBOL, { value: true });
+        // TODO: should we only have a single DeployAssert per test?
+        this.assert = new assertions_1.DeployAssert(this);
+        this._testCase = new IntegTestCase(this, `${id}TestCase`, {
+            ...props,
+            stacks: [this],
+        });
+    }
+    /**
+     * Returns whether the construct is a IntegTestCaseStack
+     */
+    static isIntegTestCaseStack(x) {
+        return x !== null && typeof (x) === 'object' && TEST_CASE_STACK_SYMBOL in x;
+    }
+}
+exports.IntegTestCaseStack = IntegTestCaseStack;
+_b = JSII_RTTI_SYMBOL_1;
+IntegTestCaseStack[_b] = { fqn: "@aws-cdk/integ-tests-alpha.IntegTestCaseStack", version: "2.25.0-alpha.0" };
+/**
  * A collection of test cases. Each test case file should contain exactly one
@@ -58,3 +108,2 @@ * instance of this class.
         super(scope, id);
-        this.props = props;
         try {
@@ -69,8 +118,27 @@ jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_IntegTestProps(props);
         }
-    }
-    onPrepare() {
-        aws_cdk_lib_1.attachCustomSynthesis(this, {
-            onSynthesize: (session) => {
-                const synthesizer = new manifest_synthesizer_1.IntegManifestSynthesizer(this.props.testCases);
-                synthesizer.synthesize(session);
+        const defaultTestCase = new IntegTestCase(this, 'DefaultTest', {
+            stacks: props.testCases.filter(stack => !IntegTestCaseStack.isIntegTestCaseStack(stack)),
+            hooks: props.hooks,
+            regions: props.regions,
+            diffAssets: props.diffAssets,
+            allowDestroy: props.allowDestroy,
+            cdkCommandOptions: props.cdkCommandOptions,
+            stackUpdateWorkflow: props.stackUpdateWorkflow,
+        });
+        this.assert = defaultTestCase.assert;
+        this.testCases = [
+            defaultTestCase,
+            ...props.testCases
+                .filter(stack => IntegTestCaseStack.isIntegTestCaseStack(stack))
+                .map(stack => stack._testCase),
+        ];
+        this.node.addValidation({
+            validate: () => {
+                aws_cdk_lib_1.attachCustomSynthesis(this, {
+                    onSynthesize: (session) => {
+                        const synthesizer = new manifest_synthesizer_1.IntegManifestSynthesizer(this.testCases);
+                        synthesizer.synthesize(session);
+                    },
+                });
+                return [];
             },
@@ -81,10 +149,4 @@ });
 exports.IntegTest = IntegTest;
-_b = JSII_RTTI_SYMBOL_1;
-IntegTest[_b] = { fqn: "@aws-cdk/integ-tests-alpha.IntegTest", version: "2.24.1-alpha.0" };
-function toTestCase(props) {
-    return {
-        ...props,
-        stacks: props.stacks.map(s => s.artifactId),
-    };
-}
-//# sourceMappingURL=data:application/json;base64,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
+_c = JSII_RTTI_SYMBOL_1;
+IntegTest[_c] = { fqn: "@aws-cdk/integ-tests-alpha.IntegTest", version: "2.25.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-case.js","sourceRoot":"","sources":["test-case.ts"],"names":[],"mappings":"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","sourcesContent":["import { IntegManifest, Manifest, TestCase, TestOptions } from 'aws-cdk-lib/cloud-assembly-schema';\nimport { attachCustomSynthesis, Stack, ISynthesisSession, StackProps } from 'aws-cdk-lib';\nimport { DeployAssert } from './assertions';\nimport { IntegManifestSynthesizer } from './manifest-synthesizer';\n\nconst TEST_CASE_STACK_SYMBOL = Symbol.for('@aws-cdk/integ-tests.IntegTestCaseStack');\n\n// keep this import separate from other imports to reduce chance for merge conflicts with v2-main\n// eslint-disable-next-line no-duplicate-imports, import/order\nimport { Construct } from 'constructs';\n\n/**\n * Properties of an integration test case\n */\nexport interface IntegTestCaseProps extends TestOptions {\n  /**\n   * Stacks to be deployed during the test\n   */\n  readonly stacks: Stack[];\n}\n\n/**\n * An integration test case. Allows the definition of test properties that\n * apply to all stacks under this case.\n *\n * It is recommended that you use the IntegTest construct since that will create\n * a default IntegTestCase\n */\nexport class IntegTestCase extends Construct {\n  /**\n   * Make assertions on resources in this test case\n   */\n  public readonly assert: DeployAssert;\n\n  constructor(scope: Construct, id: string, private readonly props: IntegTestCaseProps) {\n    super(scope, id);\n\n    this.assert = new DeployAssert(this);\n  }\n\n  /**\n   * The integration test manifest for this test case. Manifests are used\n   * by the integration test runner.\n   */\n  get manifest(): IntegManifest {\n    return {\n      version: Manifest.version(),\n      testCases: { [this.node.path]: this.toTestCase(this.props) },\n    };\n  }\n\n  private toTestCase(props: IntegTestCaseProps): TestCase {\n    return {\n      ...props,\n      assertionStack: Stack.of(this.assert).artifactId,\n      stacks: props.stacks.map(s => s.artifactId),\n    };\n  }\n}\n\n/**\n * Properties of an integration test case stack\n */\nexport interface IntegTestCaseStackProps extends TestOptions, StackProps {}\n\n/**\n * An integration test case stack. Allows the definition of test properties\n * that should apply to this stack.\n *\n * This should be used if there are multiple stacks in the integration test\n * and it is necessary to specify different test case option for each. Otherwise\n * normal stacks should be added to IntegTest\n */\nexport class IntegTestCaseStack extends Stack {\n  /**\n   * Returns whether the construct is a IntegTestCaseStack\n   */\n  public static isIntegTestCaseStack(x: any): x is IntegTestCaseStack {\n    return x !== null && typeof(x) === 'object' && TEST_CASE_STACK_SYMBOL in x;\n  }\n\n  /**\n   * Make assertions on resources in this test case\n   */\n  public readonly assert: DeployAssert;\n\n  /**\n   * The underlying IntegTestCase that is created\n   * @internal\n   */\n  public readonly _testCase: IntegTestCase;\n\n  constructor(scope: Construct, id: string, props?: IntegTestCaseStackProps) {\n    super(scope, id, props);\n\n    Object.defineProperty(this, TEST_CASE_STACK_SYMBOL, { value: true });\n\n    // TODO: should we only have a single DeployAssert per test?\n    this.assert = new DeployAssert(this);\n    this._testCase = new IntegTestCase(this, `${id}TestCase`, {\n      ...props,\n      stacks: [this],\n    });\n  }\n\n}\n\n/**\n * Integration test properties\n */\nexport interface IntegTestProps extends TestOptions {\n  /**\n   * List of test cases that make up this test\n   */\n  readonly testCases: Stack[];\n}\n\n/**\n * A collection of test cases. Each test case file should contain exactly one\n * instance of this class.\n */\nexport class IntegTest extends Construct {\n  /**\n   * Make assertions on resources in this test case\n   */\n  public readonly assert: DeployAssert;\n  private readonly testCases: IntegTestCase[];\n  constructor(scope: Construct, id: string, props: IntegTestProps) {\n    super(scope, id);\n\n    const defaultTestCase = new IntegTestCase(this, 'DefaultTest', {\n      stacks: props.testCases.filter(stack => !IntegTestCaseStack.isIntegTestCaseStack(stack)),\n      hooks: props.hooks,\n      regions: props.regions,\n      diffAssets: props.diffAssets,\n      allowDestroy: props.allowDestroy,\n      cdkCommandOptions: props.cdkCommandOptions,\n      stackUpdateWorkflow: props.stackUpdateWorkflow,\n    });\n    this.assert = defaultTestCase.assert;\n\n    this.testCases = [\n      defaultTestCase,\n      ...props.testCases\n        .filter(stack => IntegTestCaseStack.isIntegTestCaseStack(stack))\n        .map(stack => (stack as IntegTestCaseStack)._testCase),\n    ];\n\n    this.node.addValidation({\n      validate: () => {\n        attachCustomSynthesis(this, {\n          onSynthesize: (session: ISynthesisSession) => {\n            const synthesizer = new IntegManifestSynthesizer(this.testCases);\n            synthesizer.synthesize(session);\n          },\n        });\n        return [];\n      },\n    });\n  }\n}\n"]}

package.json

 {
   "name": "@aws-cdk/integ-tests-alpha",
   "description": "CDK Integration Testing Constructs",
-  "version": "2.24.1-alpha.0",
+  "version": "2.25.0-alpha.0",
   "private": false,
@@ -47,2 +47,3 @@ "main": "lib/index.js",
     "build": "cdk-build",
+    "bundle": "esbuild --bundle lib/assertions/providers/lambda-handler/index.ts --target=node14 --platform=node --external:aws-sdk --outfile=lib/assertions/providers/lambda-handler.bundle/index.js",
     "lint": "cdk-lint",
@@ -68,4 +69,4 @@ "package": "cdk-package",
   "devDependencies": {
-    "@aws-cdk/cdk-build-tools": "2.24.1",
-    "@aws-cdk/pkglint": "2.24.1",
+    "@aws-cdk/cdk-build-tools": "2.25.0",
+    "@aws-cdk/pkglint": "2.25.0",
     "@types/fs-extra": "^8.1.2",
@@ -79,3 +80,3 @@ "@types/jest": "^27.5.0",
     "aws-sdk": "^2.1093.0",
-    "aws-cdk-lib": "2.24.1",
+    "aws-cdk-lib": "2.25.0",
     "constructs": "^10.0.0"
@@ -85,3 +86,3 @@ },
   "peerDependencies": {
-    "aws-cdk-lib": "^2.24.1",
+    "aws-cdk-lib": "^2.25.0",
     "constructs": "^10.0.0"
@@ -102,2 +103,15 @@ },
   },
+  "cdk-build": {
+    "pre": [
+      "yarn bundle"
+    ],
+    "env": {
+      "AWSLINT_BASE_CONSTRUCT": true
+    }
+  },
+  "awslint": {
+    "exclude": [
+      "*:*"
+    ]
+  },
   "nozem": {
@@ -118,7 +132,2 @@ "ostools": [
   },
-  "awslint": {
-    "exclude": [
-      "*:*"
-    ]
-  },
   "pkglint": {
@@ -125,0 +134,0 @@ "exclude": [

README.md

@@ -19,4 +19,48 @@ # integ-tests
 
+## Overview
+
+This library is meant to be used in combination with the [integ-runner]() CLI
+to enable users to write and execute integration tests for AWS CDK Constructs.
+
+An integration test should be defined as a CDK application, and
+there should be a 1:1 relationship between an integration test and a CDK application.
+
+So for example, in order to create an integration test called `my-function`
+we would need to create a file to contain our integration test application.
+
+*test/integ.my-function.ts*
+
+```ts
+const app = new App();
+const stack = new Stack();
+new lambda.Function(stack, 'MyFunction', {
+  runtime: lambda.Runtime.NODEJS_12_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
+});
+```
+
+This is a self contained CDK application which we could deploy by running
+
+```bash
+cdk deploy --app 'node test/integ.my-function.js'
+```
+
+In order to turn this into an integration test, all that is needed is to
+use the `IntegTest` construct.
+
+```ts
+declare const app: App;
+declare const stack: Stack;
+new IntegTest(app, 'Integ', { testCases: [stack] });
+```
+
+You will notice that the `stack` is registered to the `IntegTest` as a test case.
+Each integration test can contain multiple test cases, which are just instances
+of a stack. See the [Usage](#usage) section for more details.
+
 ## Usage
 
+### IntegTest
+
 Suppose you have a simple stack, that only encapsulates a Lambda function with a
@@ -70,6 +114,4 @@ certain handler:
 
-const stack = new Stack(app, 'stack');
-
-const differentArchsCase = new IntegTestCase(stack, 'DifferentArchitectures', {
-  stacks: [
+new IntegTest(app, 'DifferentArchitectures', {
+  testCases: [
     new StackUnderTest(app, 'Stack1', {
@@ -83,9 +125,2 @@ architecture: lambda.Architecture.ARM_64,
 });
-
-// There must be exactly one instance of TestCase per file
-new IntegTest(app, 'integ-test', {
-
-  // Register as many test cases as you want here
-  testCases: [differentArchsCase],
-});
 ```
@@ -104,4 +139,4 @@
 
-const testCase = new IntegTestCase(stack, 'CustomizedDeploymentWorkflow', {
-  stacks: [stackUnderTest],
+const testCase = new IntegTest(app, 'CustomizedDeploymentWorkflow', {
+  testCases: [stackUnderTest],
   diffAssets: true,
@@ -123,7 +158,224 @@ stackUpdateWorkflow: true,
 });
+```
 
-new IntegTest(app, 'integ-test', {
-  testCases: [testCase],
+### IntegTestCaseStack
+
+In the majority of cases an integration test will contain a single `IntegTestCase`.
+By default when you create an `IntegTest` an `IntegTestCase` is created for you
+and all of your test cases are registered to this `IntegTestCase`. The `IntegTestCase`
+and `IntegTestCaseStack` constructs are only needed when it is necessary to
+defined different options for individual test cases.
+
+For example, you might want to have one test case where `diffAssets` is enabled.
+
+```ts
+declare const app: App;
+declare const stackUnderTest: Stack;
+const testCaseWithAssets = new IntegTestCaseStack(app, 'TestCaseAssets', {
+  diffAssets: true,
 });
+
+new IntegTest(app, 'Integ', { testCases: [stackUnderTest, testCaseWithAssets] });
 ```
 
+## Assertions
+
+This library also provides a utility to make assertions against the infrastructure that the integration test deploys.
+
+The easiest way to do this is to create a `TestCase` and then access the `DeployAssert` that is automatically created.
+
+```ts
+declare const app: App;
+declare const stack: Stack;
+
+const integ = new IntegTest(app, 'Integ', { testCases: [stack] });
+integ.assert.awsApiCall('S3', 'getObject');
+```
+
+### DeployAssert
+
+Assertions are created by using the `DeployAssert` construct. This construct creates it's own `Stack` separate from
+any stacks that you create as part of your integration tests. This `Stack` is treated differently from other stacks
+by the `integ-runner` tool. For example, this stack will not be diffed by the `integ-runner`.
+
+Any assertions that you create should be created in the scope of `DeployAssert`. For example,
+
+```ts
+declare const app: App;
+
+const assert = new DeployAssert(app);
+new AwsApiCall(assert, 'GetObject', {
+  service: 'S3',
+  api: 'getObject',
+});
+```
+
+`DeployAssert` also provides utilities to register your own assertions.
+
+```ts
+declare const myCustomResource: CustomResource;
+declare const app: App;
+const assert = new DeployAssert(app);
+assert.assert(
+  'CustomAssertion',
+  ExpectedResult.objectLike({ foo: 'bar' }),
+  ActualResult.fromCustomResource(myCustomResource, 'data'),
+);
+```
+
+In the above example an assertion is created that will trigger a user defined `CustomResource`
+and assert that the `data` attribute is equal to `{ foo: 'bar' }`.
+
+### AwsApiCall
+
+A common method to retrieve the "actual" results to compare with what is expected is to make an
+AWS API call to receive some data. This library does this by utilizing CloudFormation custom resources
+which means that CloudFormation will call out to a Lambda Function which will
+use the AWS JavaScript SDK to make the API call.
+
+This can be done by using the class directory:
+
+```ts
+declare const assert: DeployAssert;
+
+new AwsApiCall(assert, 'MyAssertion', {
+  service: 'SQS',
+  api: 'receiveMessage',
+  parameters: {
+    QueueUrl: 'url',
+  },
+});
+```
+
+Or by using the `awsApiCall` method on `DeployAssert`:
+
+```ts
+declare const app: App;
+const assert = new DeployAssert(app);
+assert.awsApiCall('SQS', 'receiveMessage', {
+  QueueUrl: 'url',
+});
+```
+
+### EqualsAssertion
+
+This library currently provides the ability to assert that two values are equal
+to one another by utilizing the `EqualsAssertion` class. This utilizes a Lambda
+backed `CustomResource` which in tern uses the [Match](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.assertions.Match.html) utility from the
+[@aws-cdk/assertions](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.assertions-readme.html) library. 
+
+
+```ts
+declare const app: App;
+declare const stack: Stack;
+declare const queue: sqs.Queue;
+declare const fn: lambda.IFunction;
+
+const integ = new IntegTest(app, 'Integ', {
+  testCases: [stack],
+});
+
+integ.assert.invokeFunction({
+  functionName: fn.functionName,
+  invocationType: InvocationType.EVENT,
+  payload: JSON.stringify({ status: 'OK' }),
+});
+
+const message = integ.assert.awsApiCall('SQS', 'receiveMessage', {
+  QueueUrl: queue.queueUrl,
+  WaitTimeSeconds: 20,
+});
+
+new EqualsAssertion(integ.assert, 'ReceiveMessage', {
+  actual: ActualResult.fromAwsApiCall(message, 'Messages.0.Body'),
+  expected: ExpectedResult.objectLike({
+    requestContext: {
+      condition: 'Success',
+    },
+    requestPayload: {
+      status: 'OK',
+    },
+    responseContext: {
+      statusCode: 200,
+    },
+    responsePayload: 'success',
+  }),
+});
+```
+
+#### Match
+
+`integ-tests` also provides a `Match` utility similar to the `@aws-cdk/assertions` module. `Match`
+can be used to construct the `ExpectedResult`.
+
+```ts
+declare const message: AwsApiCall;
+declare const assert: DeployAssert;
+
+message.assert(ExpectedResult.objectLike({
+  Messages: Match.arrayWith([
+    {
+	  Body: {
+	    Values: Match.arrayWith([{ Asdf: 3 }]),
+		Message: Match.stringLikeRegexp('message'),
+	  },
+    },
+  ]),
+}));
+```
+
+### Examples
+
+#### Invoke a Lambda Function
+
+In this example there is a Lambda Function that is invoked and
+we assert that the payload that is returned is equal to '200'.
+
+```ts
+declare const lambdaFunction: lambda.IFunction;
+declare const app: App;
+
+const stack = new Stack(app, 'cdk-integ-lambda-bundling');
+
+const integ = new IntegTest(app, 'IntegTest', {
+  testCases: [stack],
+});
+
+const invoke = integ.assert.invokeFunction({
+  functionName: lambdaFunction.functionName,
+});
+invoke.assert(ExpectedResult.objectLike({
+  Payload: '200',
+}));
+```
+
+#### Make an AWS API Call
+
+In this example there is a StepFunctions state machine that is executed
+and then we assert that the result of the execution is successful.
+
+```ts
+declare const app: App;
+declare const stack: Stack;
+declare const sm: IStateMachine;
+
+const testCase = new IntegTest(app, 'IntegTest', {
+  testCases: [stack],
+});
+
+// Start an execution
+const start = testCase.assert.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+});
+
+// describe the results of the execution
+const describe = testCase.assert.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+
+// assert the results
+describe.assert(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+}));
+```
+

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

705832

increased by132.26%

Number of package files

51

increased by15.91%

Lines of code

7735

increased by161.49%

Number of lines in readme file

377

increased by201.6%

Worsened metrics

Number of low supply chain risk alerts

13

increased by225%

Number of medium supply chain risk alerts

3

increased by200%

No dependency changes