cdk-common 0.0.67 → 2.0.2

package/node_modules/@aws-cdk/assert/lib/assertions/have-resource.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSuperObject = exports.ResourcePart = exports.HaveResourceAssertion = exports.haveResourceLike = exports.haveResource = exports.ABSENT = void 0;
+const assertion_1 = require("../assertion");
+const have_resource_matchers_1 = require("./have-resource-matchers");
+/**
+ * Magic value to signify that a certain key should be absent from the property bag.
+ *
+ * The property is either not present or set to `undefined.
+ *
+ * NOTE: `ABSENT` only works with the `haveResource()` and `haveResourceLike()`
+ * assertions.
+ */
+exports.ABSENT = '{{ABSENT}}';
+/**
+ * An assertion to check whether a resource of a given type and with the given properties exists, disregarding properties
+ *
+ * @param resourceType the type of the resource that is expected to be present.
+ * @param properties   the properties that the resource is expected to have. A function may be provided, in which case
+ *                     it will be called with the properties of candidate resources and an ``InspectionFailure``
+ *                     instance on which errors should be appended, and should return a truthy value to denote a match.
+ * @param comparison   the entity that is being asserted against.
+ * @param allowValueExtension if properties is an object, tells whether values must match exactly, or if they are
+ *                     allowed to be supersets of the reference values. Meaningless if properties is a function.
+ */
+function haveResource(resourceType, properties, comparison, allowValueExtension = false) {
+    return new HaveResourceAssertion(resourceType, properties, comparison, allowValueExtension);
+}
+exports.haveResource = haveResource;
+/**
+ * Sugar for calling ``haveResource`` with ``allowValueExtension`` set to ``true``.
+ */
+function haveResourceLike(resourceType, properties, comparison) {
+    return haveResource(resourceType, properties, comparison, true);
+}
+exports.haveResourceLike = haveResourceLike;
+class HaveResourceAssertion extends assertion_1.JestFriendlyAssertion {
+    constructor(resourceType, properties, part, allowValueExtension = false) {
+        super();
+        this.resourceType = resourceType;
+        this.inspected = [];
+        this.matcher = isCallable(properties) ? properties :
+            properties === undefined ? have_resource_matchers_1.anything() :
+                allowValueExtension ? have_resource_matchers_1.deepObjectLike(properties) :
+                    have_resource_matchers_1.objectLike(properties);
+        this.part = part !== null && part !== void 0 ? part : ResourcePart.Properties;
+    }
+    assertUsing(inspector) {
+        var _a;
+        for (const logicalId of Object.keys(inspector.value.Resources || {})) {
+            const resource = inspector.value.Resources[logicalId];
+            if (resource.Type === this.resourceType) {
+                const propsToCheck = this.part === ResourcePart.Properties ? ((_a = resource.Properties) !== null && _a !== void 0 ? _a : {}) : resource;
+                // Pass inspection object as 2nd argument, initialize failure with default string,
+                // to maintain backwards compatibility with old predicate API.
+                const inspection = { resource, failureReason: 'Object did not match predicate' };
+                if (have_resource_matchers_1.match(propsToCheck, this.matcher, inspection)) {
+                    return true;
+                }
+                this.inspected.push(inspection);
+            }
+        }
+        return false;
+    }
+    generateErrorMessage() {
+        const lines = [];
+        lines.push(`None of ${this.inspected.length} resources matches ${this.description}.`);
+        for (const inspected of this.inspected) {
+            lines.push(`- ${inspected.failureReason} in:`);
+            lines.push(indent(4, JSON.stringify(inspected.resource, null, 2)));
+        }
+        return lines.join('\n');
+    }
+    assertOrThrow(inspector) {
+        if (!this.assertUsing(inspector)) {
+            throw new Error(this.generateErrorMessage());
+        }
+    }
+    get description() {
+        // eslint-disable-next-line max-len
+        return `resource '${this.resourceType}' with ${JSON.stringify(this.matcher, undefined, 2)}`;
+    }
+}
+exports.HaveResourceAssertion = HaveResourceAssertion;
+function indent(n, s) {
+    const prefix = ' '.repeat(n);
+    return prefix + s.replace(/\n/g, '\n' + prefix);
+}
+/**
+ * What part of the resource to compare
+ */
+var ResourcePart;
+(function (ResourcePart) {
+    /**
+     * Only compare the resource's properties
+     */
+    ResourcePart[ResourcePart["Properties"] = 0] = "Properties";
+    /**
+     * Check the entire CloudFormation config
+     *
+     * (including UpdateConfig, DependsOn, etc.)
+     */
+    ResourcePart[ResourcePart["CompleteDefinition"] = 1] = "CompleteDefinition";
+})(ResourcePart = exports.ResourcePart || (exports.ResourcePart = {}));
+/**
+ * Whether a value is a callable
+ */
+function isCallable(x) {
+    return x && {}.toString.call(x) === '[object Function]';
+}
+/**
+ * Return whether `superObj` is a super-object of `obj`.
+ *
+ * A super-object has the same or more property values, recursing into sub properties if ``allowValueExtension`` is true.
+ *
+ * At any point in the object, a value may be replaced with a function which will be used to check that particular field.
+ * The type of a matcher function is expected to be of type PropertyMatcher.
+ *
+ * @deprecated - Use `objectLike` or a literal object instead.
+ */
+function isSuperObject(superObj, pattern, errors = [], allowValueExtension = false) {
+    const matcher = allowValueExtension ? have_resource_matchers_1.deepObjectLike(pattern) : have_resource_matchers_1.objectLike(pattern);
+    const inspection = { resource: superObj, failureReason: '' };
+    const ret = have_resource_matchers_1.match(superObj, matcher, inspection);
+    if (!ret) {
+        errors.push(inspection.failureReason);
+    }
+    return ret;
+}
+exports.isSuperObject = isSuperObject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"have-resource.js","sourceRoot":"","sources":["have-resource.ts"],"names":[],"mappings":"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","sourcesContent":["import { Assertion, JestFriendlyAssertion } from '../assertion';\nimport { StackInspector } from '../inspector';\nimport { anything, deepObjectLike, match, objectLike } from './have-resource-matchers';\n\n/**\n * Magic value to signify that a certain key should be absent from the property bag.\n *\n * The property is either not present or set to `undefined.\n *\n * NOTE: `ABSENT` only works with the `haveResource()` and `haveResourceLike()`\n * assertions.\n */\nexport const ABSENT = '{{ABSENT}}';\n\n/**\n * An assertion to check whether a resource of a given type and with the given properties exists, disregarding properties\n *\n * @param resourceType the type of the resource that is expected to be present.\n * @param properties   the properties that the resource is expected to have. A function may be provided, in which case\n *                     it will be called with the properties of candidate resources and an ``InspectionFailure``\n *                     instance on which errors should be appended, and should return a truthy value to denote a match.\n * @param comparison   the entity that is being asserted against.\n * @param allowValueExtension if properties is an object, tells whether values must match exactly, or if they are\n *                     allowed to be supersets of the reference values. Meaningless if properties is a function.\n */\nexport function haveResource(\n  resourceType: string,\n  properties?: any,\n  comparison?: ResourcePart,\n  allowValueExtension: boolean = false): Assertion<StackInspector> {\n  return new HaveResourceAssertion(resourceType, properties, comparison, allowValueExtension);\n}\n\n/**\n * Sugar for calling ``haveResource`` with ``allowValueExtension`` set to ``true``.\n */\nexport function haveResourceLike(\n  resourceType: string,\n  properties?: any,\n  comparison?: ResourcePart) {\n  return haveResource(resourceType, properties, comparison, true);\n}\n\nexport type PropertyMatcher = (props: any, inspection: InspectionFailure) => boolean;\n\nexport class HaveResourceAssertion extends JestFriendlyAssertion<StackInspector> {\n  private readonly inspected: InspectionFailure[] = [];\n  private readonly part: ResourcePart;\n  private readonly matcher: any;\n\n  constructor(\n    private readonly resourceType: string,\n    properties?: any,\n    part?: ResourcePart,\n    allowValueExtension: boolean = false) {\n    super();\n\n    this.matcher = isCallable(properties) ? properties :\n      properties === undefined ? anything() :\n        allowValueExtension ? deepObjectLike(properties) :\n          objectLike(properties);\n    this.part = part ?? ResourcePart.Properties;\n  }\n\n  public assertUsing(inspector: StackInspector): boolean {\n    for (const logicalId of Object.keys(inspector.value.Resources || {})) {\n      const resource = inspector.value.Resources[logicalId];\n      if (resource.Type === this.resourceType) {\n        const propsToCheck = this.part === ResourcePart.Properties ? (resource.Properties ?? {}) : resource;\n\n        // Pass inspection object as 2nd argument, initialize failure with default string,\n        // to maintain backwards compatibility with old predicate API.\n        const inspection = { resource, failureReason: 'Object did not match predicate' };\n\n        if (match(propsToCheck, this.matcher, inspection)) {\n          return true;\n        }\n\n        this.inspected.push(inspection);\n      }\n    }\n\n    return false;\n  }\n\n  public generateErrorMessage() {\n    const lines: string[] = [];\n    lines.push(`None of ${this.inspected.length} resources matches ${this.description}.`);\n\n    for (const inspected of this.inspected) {\n      lines.push(`- ${inspected.failureReason} in:`);\n      lines.push(indent(4, JSON.stringify(inspected.resource, null, 2)));\n    }\n\n    return lines.join('\\n');\n  }\n\n  public assertOrThrow(inspector: StackInspector) {\n    if (!this.assertUsing(inspector)) {\n      throw new Error(this.generateErrorMessage());\n    }\n  }\n\n  public get description(): string {\n    // eslint-disable-next-line max-len\n    return `resource '${this.resourceType}' with ${JSON.stringify(this.matcher, undefined, 2)}`;\n  }\n}\n\nfunction indent(n: number, s: string) {\n  const prefix = ' '.repeat(n);\n  return prefix + s.replace(/\\n/g, '\\n' + prefix);\n}\n\nexport interface InspectionFailure {\n  resource: any;\n  failureReason: string;\n}\n\n/**\n * What part of the resource to compare\n */\nexport enum ResourcePart {\n  /**\n   * Only compare the resource's properties\n   */\n  Properties,\n\n  /**\n   * Check the entire CloudFormation config\n   *\n   * (including UpdateConfig, DependsOn, etc.)\n   */\n  CompleteDefinition\n}\n\n/**\n * Whether a value is a callable\n */\nfunction isCallable(x: any): x is ((...args: any[]) => any) {\n  return x && {}.toString.call(x) === '[object Function]';\n}\n\n/**\n * Return whether `superObj` is a super-object of `obj`.\n *\n * A super-object has the same or more property values, recursing into sub properties if ``allowValueExtension`` is true.\n *\n * At any point in the object, a value may be replaced with a function which will be used to check that particular field.\n * The type of a matcher function is expected to be of type PropertyMatcher.\n *\n * @deprecated - Use `objectLike` or a literal object instead.\n */\nexport function isSuperObject(superObj: any, pattern: any, errors: string[] = [], allowValueExtension: boolean = false): boolean {\n  const matcher = allowValueExtension ? deepObjectLike(pattern) : objectLike(pattern);\n\n  const inspection: InspectionFailure = { resource: superObj, failureReason: '' };\n  const ret = match(superObj, matcher, inspection);\n  if (!ret) {\n    errors.push(inspection.failureReason);\n  }\n  return ret;\n}\n"]}

package/node_modules/@aws-cdk/assert/lib/assertions/have-type.d.ts

@@ -0,0 +1,3 @@
+import { Assertion } from '../assertion';
+import { StackPathInspector } from '../inspector';
+export declare function haveType(type: string): Assertion<StackPathInspector>;

package/node_modules/@aws-cdk/assert/lib/assertions/have-type.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.haveType = void 0;
+const assertion_1 = require("../assertion");
+function haveType(type) {
+    return new StackPathHasTypeAssertion(type);
+}
+exports.haveType = haveType;
+class StackPathHasTypeAssertion extends assertion_1.Assertion {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    assertUsing(inspector) {
+        const resource = inspector.value;
+        return resource !== undefined && resource.Type === this.type;
+    }
+    get description() {
+        return `resource of type ${this.type}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGF2ZS10eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaGF2ZS10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDRDQUF5QztBQUd6QyxTQUFnQixRQUFRLENBQUMsSUFBWTtJQUNuQyxPQUFPLElBQUkseUJBQXlCLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDN0MsQ0FBQztBQUZELDRCQUVDO0FBRUQsTUFBTSx5QkFBMEIsU0FBUSxxQkFBNkI7SUFDbkUsWUFBNkIsSUFBWTtRQUN2QyxLQUFLLEVBQUUsQ0FBQztRQURtQixTQUFJLEdBQUosSUFBSSxDQUFRO0lBRXpDLENBQUM7SUFFTSxXQUFXLENBQUMsU0FBNkI7UUFDOUMsTUFBTSxRQUFRLEdBQUcsU0FBUyxDQUFDLEtBQUssQ0FBQztRQUNqQyxPQUFPLFFBQVEsS0FBSyxTQUFTLElBQUksUUFBUSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQy9ELENBQUM7SUFFRCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxvQkFBb0IsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3pDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFzc2VydGlvbiB9IGZyb20gJy4uL2Fzc2VydGlvbic7XG5pbXBvcnQgeyBTdGFja1BhdGhJbnNwZWN0b3IgfSBmcm9tICcuLi9pbnNwZWN0b3InO1xuXG5leHBvcnQgZnVuY3Rpb24gaGF2ZVR5cGUodHlwZTogc3RyaW5nKTogQXNzZXJ0aW9uPFN0YWNrUGF0aEluc3BlY3Rvcj4ge1xuICByZXR1cm4gbmV3IFN0YWNrUGF0aEhhc1R5cGVBc3NlcnRpb24odHlwZSk7XG59XG5cbmNsYXNzIFN0YWNrUGF0aEhhc1R5cGVBc3NlcnRpb24gZXh0ZW5kcyBBc3NlcnRpb248U3RhY2tQYXRoSW5zcGVjdG9yPiB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgdHlwZTogc3RyaW5nKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIHB1YmxpYyBhc3NlcnRVc2luZyhpbnNwZWN0b3I6IFN0YWNrUGF0aEluc3BlY3Rvcik6IGJvb2xlYW4ge1xuICAgIGNvbnN0IHJlc291cmNlID0gaW5zcGVjdG9yLnZhbHVlO1xuICAgIHJldHVybiByZXNvdXJjZSAhPT0gdW5kZWZpbmVkICYmIHJlc291cmNlLlR5cGUgPT09IHRoaXMudHlwZTtcbiAgfVxuXG4gIHB1YmxpYyBnZXQgZGVzY3JpcHRpb24oKTogc3RyaW5nIHtcbiAgICByZXR1cm4gYHJlc291cmNlIG9mIHR5cGUgJHt0aGlzLnR5cGV9YDtcbiAgfVxufVxuIl19

package/node_modules/@aws-cdk/assert/lib/assertions/match-template.d.ts

@@ -0,0 +1,19 @@
+import { Assertion } from '../assertion';
+import { StackInspector } from '../inspector';
+export declare enum MatchStyle {
+    /** Requires an exact match */
+    EXACT = "exactly",
+    /** Allows any change that does not cause a resource replacement */
+    NO_REPLACES = "no replaces",
+    /** Allows additions, but no updates */
+    SUPERSET = "superset"
+}
+export declare function exactlyMatchTemplate(template: {
+    [key: string]: any;
+}): Assertion<StackInspector>;
+export declare function beASupersetOfTemplate(template: {
+    [key: string]: any;
+}): Assertion<StackInspector>;
+export declare function matchTemplate(template: {
+    [key: string]: any;
+}, matchStyle?: MatchStyle): Assertion<StackInspector>;

package/node_modules/@aws-cdk/assert/lib/assertions/match-template.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchTemplate = exports.beASupersetOfTemplate = exports.exactlyMatchTemplate = exports.MatchStyle = void 0;
+const cfnDiff = require("@aws-cdk/cloudformation-diff");
+const assertion_1 = require("../assertion");
+var MatchStyle;
+(function (MatchStyle) {
+    /** Requires an exact match */
+    MatchStyle["EXACT"] = "exactly";
+    /** Allows any change that does not cause a resource replacement */
+    MatchStyle["NO_REPLACES"] = "no replaces";
+    /** Allows additions, but no updates */
+    MatchStyle["SUPERSET"] = "superset";
+})(MatchStyle = exports.MatchStyle || (exports.MatchStyle = {}));
+function exactlyMatchTemplate(template) {
+    return matchTemplate(template, MatchStyle.EXACT);
+}
+exports.exactlyMatchTemplate = exactlyMatchTemplate;
+function beASupersetOfTemplate(template) {
+    return matchTemplate(template, MatchStyle.SUPERSET);
+}
+exports.beASupersetOfTemplate = beASupersetOfTemplate;
+function matchTemplate(template, matchStyle = MatchStyle.EXACT) {
+    return new StackMatchesTemplateAssertion(template, matchStyle);
+}
+exports.matchTemplate = matchTemplate;
+class StackMatchesTemplateAssertion extends assertion_1.Assertion {
+    constructor(template, matchStyle) {
+        super();
+        this.template = template;
+        this.matchStyle = matchStyle;
+    }
+    assertOrThrow(inspector) {
+        if (!this.assertUsing(inspector)) {
+            // The details have already been printed, so don't generate a huge error message
+            throw new Error('Template comparison produced unacceptable match');
+        }
+    }
+    assertUsing(inspector) {
+        const diff = cfnDiff.diffTemplate(this.template, inspector.value);
+        const acceptable = this.isDiffAcceptable(diff);
+        if (!acceptable) {
+            // Print the diff
+            cfnDiff.formatDifferences(process.stderr, diff);
+            // Print the actual template
+            process.stdout.write('--------------------------------------------------------------------------------------\n');
+            process.stdout.write(JSON.stringify(inspector.value, undefined, 2) + '\n');
+        }
+        return acceptable;
+    }
+    isDiffAcceptable(diff) {
+        switch (this.matchStyle) {
+            case MatchStyle.EXACT:
+                return diff.differenceCount === 0;
+            case MatchStyle.NO_REPLACES:
+                for (const change of Object.values(diff.resources.changes)) {
+                    if (change.changeImpact === cfnDiff.ResourceImpact.MAY_REPLACE) {
+                        return false;
+                    }
+                    if (change.changeImpact === cfnDiff.ResourceImpact.WILL_REPLACE) {
+                        return false;
+                    }
+                }
+                for (const change of Object.values(diff.parameters.changes)) {
+                    if (change.isUpdate) {
+                        return false;
+                    }
+                }
+                for (const change of Object.values(diff.outputs.changes)) {
+                    if (change.isUpdate) {
+                        return false;
+                    }
+                }
+                return true;
+            case MatchStyle.SUPERSET:
+                for (const change of Object.values(diff.resources.changes)) {
+                    if (change.changeImpact !== cfnDiff.ResourceImpact.WILL_CREATE) {
+                        return false;
+                    }
+                }
+                for (const change of Object.values(diff.parameters.changes)) {
+                    if (!change.isAddition) {
+                        return false;
+                    }
+                }
+                for (const change of Object.values(diff.outputs.changes)) {
+                    if (!change.isAddition) {
+                        return false;
+                    }
+                }
+                return true;
+        }
+    }
+    get description() {
+        return `template (${this.matchStyle}): ${JSON.stringify(this.template, null, 2)}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-template.js","sourceRoot":"","sources":["match-template.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cfnDiff from '@aws-cdk/cloudformation-diff';\nimport { Assertion } from '../assertion';\nimport { StackInspector } from '../inspector';\n\nexport enum MatchStyle {\n  /** Requires an exact match */\n  EXACT = 'exactly',\n  /** Allows any change that does not cause a resource replacement */\n  NO_REPLACES = 'no replaces',\n  /** Allows additions, but no updates */\n  SUPERSET = 'superset'\n}\n\nexport function exactlyMatchTemplate(template: { [key: string]: any }) {\n  return matchTemplate(template, MatchStyle.EXACT);\n}\n\nexport function beASupersetOfTemplate(template: { [key: string]: any }) {\n  return matchTemplate(template, MatchStyle.SUPERSET);\n}\n\nexport function matchTemplate(\n  template: { [key: string]: any },\n  matchStyle: MatchStyle = MatchStyle.EXACT): Assertion<StackInspector> {\n  return new StackMatchesTemplateAssertion(template, matchStyle);\n}\n\nclass StackMatchesTemplateAssertion extends Assertion<StackInspector> {\n  constructor(\n    private readonly template: { [key: string]: any },\n    private readonly matchStyle: MatchStyle) {\n    super();\n  }\n\n  public assertOrThrow(inspector: StackInspector) {\n    if (!this.assertUsing(inspector)) {\n      // The details have already been printed, so don't generate a huge error message\n      throw new Error('Template comparison produced unacceptable match');\n    }\n  }\n\n  public assertUsing(inspector: StackInspector): boolean {\n    const diff = cfnDiff.diffTemplate(this.template, inspector.value);\n    const acceptable = this.isDiffAcceptable(diff);\n    if (!acceptable) {\n      // Print the diff\n      cfnDiff.formatDifferences(process.stderr, diff);\n\n      // Print the actual template\n      process.stdout.write('--------------------------------------------------------------------------------------\\n');\n      process.stdout.write(JSON.stringify(inspector.value, undefined, 2) + '\\n');\n    }\n\n    return acceptable;\n  }\n\n  private isDiffAcceptable(diff: cfnDiff.TemplateDiff): boolean {\n    switch (this.matchStyle) {\n      case MatchStyle.EXACT:\n        return diff.differenceCount === 0;\n      case MatchStyle.NO_REPLACES:\n        for (const change of Object.values(diff.resources.changes)) {\n          if (change.changeImpact === cfnDiff.ResourceImpact.MAY_REPLACE) { return false; }\n          if (change.changeImpact === cfnDiff.ResourceImpact.WILL_REPLACE) { return false; }\n        }\n\n        for (const change of Object.values(diff.parameters.changes)) {\n          if (change.isUpdate) { return false; }\n        }\n\n        for (const change of Object.values(diff.outputs.changes)) {\n          if (change.isUpdate) { return false; }\n        }\n        return true;\n      case MatchStyle.SUPERSET:\n        for (const change of Object.values(diff.resources.changes)) {\n          if (change.changeImpact !== cfnDiff.ResourceImpact.WILL_CREATE) { return false; }\n        }\n\n        for (const change of Object.values(diff.parameters.changes)) {\n          if (!change.isAddition) { return false; }\n        }\n\n        for (const change of Object.values(diff.outputs.changes)) {\n          if (!change.isAddition) { return false; }\n        }\n\n        return true;\n    }\n  }\n\n  public get description(): string {\n    return `template (${this.matchStyle}): ${JSON.stringify(this.template, null, 2)}`;\n  }\n}\n"]}

package/node_modules/@aws-cdk/assert/lib/assertions/negated-assertion.d.ts

@@ -0,0 +1,8 @@
+import { Assertion } from '../assertion';
+import { Inspector } from '../inspector';
+export declare class NegatedAssertion<I extends Inspector> extends Assertion<I> {
+    private readonly negated;
+    constructor(negated: Assertion<I>);
+    assertUsing(inspector: I): boolean;
+    get description(): string;
+}

package/node_modules/@aws-cdk/assert/lib/assertions/negated-assertion.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NegatedAssertion = void 0;
+const assertion_1 = require("../assertion");
+class NegatedAssertion extends assertion_1.Assertion {
+    constructor(negated) {
+        super();
+        this.negated = negated;
+    }
+    assertUsing(inspector) {
+        return !this.negated.assertUsing(inspector);
+    }
+    get description() {
+        return `not ${this.negated.description}`;
+    }
+}
+exports.NegatedAssertion = NegatedAssertion;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmVnYXRlZC1hc3NlcnRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJuZWdhdGVkLWFzc2VydGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw0Q0FBeUM7QUFHekMsTUFBYSxnQkFBc0MsU0FBUSxxQkFBWTtJQUNyRSxZQUE2QixPQUFxQjtRQUNoRCxLQUFLLEVBQUUsQ0FBQztRQURtQixZQUFPLEdBQVAsT0FBTyxDQUFjO0lBRWxELENBQUM7SUFFTSxXQUFXLENBQUMsU0FBWTtRQUM3QixPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVELElBQVcsV0FBVztRQUNwQixPQUFPLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUMzQyxDQUFDO0NBQ0Y7QUFaRCw0Q0FZQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFzc2VydGlvbiB9IGZyb20gJy4uL2Fzc2VydGlvbic7XG5pbXBvcnQgeyBJbnNwZWN0b3IgfSBmcm9tICcuLi9pbnNwZWN0b3InO1xuXG5leHBvcnQgY2xhc3MgTmVnYXRlZEFzc2VydGlvbjxJIGV4dGVuZHMgSW5zcGVjdG9yPiBleHRlbmRzIEFzc2VydGlvbjxJPiB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgbmVnYXRlZDogQXNzZXJ0aW9uPEk+KSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIHB1YmxpYyBhc3NlcnRVc2luZyhpbnNwZWN0b3I6IEkpOiBib29sZWFuIHtcbiAgICByZXR1cm4gIXRoaXMubmVnYXRlZC5hc3NlcnRVc2luZyhpbnNwZWN0b3IpO1xuICB9XG5cbiAgcHVibGljIGdldCBkZXNjcmlwdGlvbigpOiBzdHJpbmcge1xuICAgIHJldHVybiBgbm90ICR7dGhpcy5uZWdhdGVkLmRlc2NyaXB0aW9ufWA7XG4gIH1cbn1cbiJdfQ==

package/node_modules/@aws-cdk/assert/lib/canonicalize-assets.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reduce template to a normal form where asset references have been normalized
+ *
+ * This makes it possible to compare templates if all that's different between
+ * them is the hashes of the asset values.
+ *
+ * Currently only handles parameterized assets, but can (and should)
+ * be adapted to handle convention-mode assets as well when we start using
+ * more of those.
+ */
+export declare function canonicalizeTemplate(template: any): any;

package/node_modules/@aws-cdk/assert/lib/canonicalize-assets.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizeTemplate = void 0;
+/**
+ * Reduce template to a normal form where asset references have been normalized
+ *
+ * This makes it possible to compare templates if all that's different between
+ * them is the hashes of the asset values.
+ *
+ * Currently only handles parameterized assets, but can (and should)
+ * be adapted to handle convention-mode assets as well when we start using
+ * more of those.
+ */
+function canonicalizeTemplate(template) {
+    // For the weird case where we have an array of templates...
+    if (Array.isArray(template)) {
+        return template.map(canonicalizeTemplate);
+    }
+    // Find assets via parameters
+    const stringSubstitutions = new Array();
+    const paramRe = /^AssetParameters([a-zA-Z0-9]{64})(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})$/;
+    const assetsSeen = new Set();
+    for (const paramName of Object.keys((template === null || template === void 0 ? void 0 : template.Parameters) || {})) {
+        const m = paramRe.exec(paramName);
+        if (!m) {
+            continue;
+        }
+        if (assetsSeen.has(m[1])) {
+            continue;
+        }
+        assetsSeen.add(m[1]);
+        const ix = assetsSeen.size;
+        // Full parameter reference
+        stringSubstitutions.push([
+            new RegExp(`AssetParameters${m[1]}(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})`),
+            `Asset${ix}$1`,
+        ]);
+        // Substring asset hash reference
+        stringSubstitutions.push([
+            new RegExp(`${m[1]}`),
+            `Asset${ix}Hash`,
+        ]);
+    }
+    // Substitute them out
+    return substitute(template);
+    function substitute(what) {
+        if (Array.isArray(what)) {
+            return what.map(substitute);
+        }
+        if (typeof what === 'object' && what !== null) {
+            const ret = {};
+            for (const [k, v] of Object.entries(what)) {
+                ret[stringSub(k)] = substitute(v);
+            }
+            return ret;
+        }
+        if (typeof what === 'string') {
+            return stringSub(what);
+        }
+        return what;
+    }
+    function stringSub(x) {
+        for (const [re, replacement] of stringSubstitutions) {
+            x = x.replace(re, replacement);
+        }
+        return x;
+    }
+}
+exports.canonicalizeTemplate = canonicalizeTemplate;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-cdk/assert/lib/expect.d.ts

@@ -0,0 +1,4 @@
+import * as cdk from 'aws-cdk-lib';
+import * as api from 'aws-cdk-lib/cx-api';
+import { StackInspector } from './inspector';
+export declare function expect(stack: api.CloudFormationStackArtifact | cdk.Stack | Record<string, any>, skipValidation?: boolean): StackInspector;

package/node_modules/@aws-cdk/assert/lib/expect.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = void 0;
+const cdk = require("aws-cdk-lib");
+const api = require("aws-cdk-lib/cx-api");
+const inspector_1 = require("./inspector");
+const synth_utils_1 = require("./synth-utils");
+function expect(stack, skipValidation = false) {
+    // if this is already a synthesized stack, then just inspect it.
+    const artifact = stack instanceof api.CloudFormationStackArtifact ? stack
+        : cdk.Stack.isStack(stack) ? synth_utils_1.SynthUtils._synthesizeWithNested(stack, { skipValidation })
+            : stack; // This is a template already
+    return new inspector_1.StackInspector(artifact);
+}
+exports.expect = expect;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZXhwZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQUFtQztBQUNuQywwQ0FBMEM7QUFDMUMsMkNBQTZDO0FBQzdDLCtDQUEyQztBQUUzQyxTQUFnQixNQUFNLENBQUMsS0FBd0UsRUFBRSxjQUFjLEdBQUcsS0FBSztJQUNySCxnRUFBZ0U7SUFDaEUsTUFBTSxRQUFRLEdBQUcsS0FBSyxZQUFZLEdBQUcsQ0FBQywyQkFBMkIsQ0FBQyxDQUFDLENBQUMsS0FBSztRQUN2RSxDQUFDLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLHdCQUFVLENBQUMscUJBQXFCLENBQUMsS0FBSyxFQUFFLEVBQUUsY0FBYyxFQUFFLENBQUM7WUFDdEYsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLDZCQUE2QjtJQUMxQyxPQUFPLElBQUksMEJBQWMsQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUN0QyxDQUFDO0FBTkQsd0JBTUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBjZGsgZnJvbSAnYXdzLWNkay1saWInO1xuaW1wb3J0ICogYXMgYXBpIGZyb20gJ2F3cy1jZGstbGliL2N4LWFwaSc7XG5pbXBvcnQgeyBTdGFja0luc3BlY3RvciB9IGZyb20gJy4vaW5zcGVjdG9yJztcbmltcG9ydCB7IFN5bnRoVXRpbHMgfSBmcm9tICcuL3N5bnRoLXV0aWxzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGV4cGVjdChzdGFjazogYXBpLkNsb3VkRm9ybWF0aW9uU3RhY2tBcnRpZmFjdCB8IGNkay5TdGFjayB8IFJlY29yZDxzdHJpbmcsIGFueT4sIHNraXBWYWxpZGF0aW9uID0gZmFsc2UpOiBTdGFja0luc3BlY3RvciB7XG4gIC8vIGlmIHRoaXMgaXMgYWxyZWFkeSBhIHN5bnRoZXNpemVkIHN0YWNrLCB0aGVuIGp1c3QgaW5zcGVjdCBpdC5cbiAgY29uc3QgYXJ0aWZhY3QgPSBzdGFjayBpbnN0YW5jZW9mIGFwaS5DbG91ZEZvcm1hdGlvblN0YWNrQXJ0aWZhY3QgPyBzdGFja1xuICAgIDogY2RrLlN0YWNrLmlzU3RhY2soc3RhY2spID8gU3ludGhVdGlscy5fc3ludGhlc2l6ZVdpdGhOZXN0ZWQoc3RhY2ssIHsgc2tpcFZhbGlkYXRpb24gfSlcbiAgICAgIDogc3RhY2s7IC8vIFRoaXMgaXMgYSB0ZW1wbGF0ZSBhbHJlYWR5XG4gIHJldHVybiBuZXcgU3RhY2tJbnNwZWN0b3IoYXJ0aWZhY3QpO1xufVxuIl19

package/node_modules/@aws-cdk/assert/lib/index.d.ts

@@ -0,0 +1,14 @@
+export * from './assertion';
+export * from './canonicalize-assets';
+export * from './expect';
+export * from './inspector';
+export * from './synth-utils';
+export * from './assertions/exist';
+export * from './assertions/have-output';
+export * from './assertions/have-resource';
+export * from './assertions/have-resource-matchers';
+export * from './assertions/have-type';
+export * from './assertions/match-template';
+export * from './assertions/and-assertion';
+export * from './assertions/negated-assertion';
+export * from './assertions/count-resources';

package/node_modules/@aws-cdk/assert/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assertion"), exports);
+__exportStar(require("./canonicalize-assets"), exports);
+__exportStar(require("./expect"), exports);
+__exportStar(require("./inspector"), exports);
+__exportStar(require("./synth-utils"), exports);
+__exportStar(require("./assertions/exist"), exports);
+__exportStar(require("./assertions/have-output"), exports);
+__exportStar(require("./assertions/have-resource"), exports);
+__exportStar(require("./assertions/have-resource-matchers"), exports);
+__exportStar(require("./assertions/have-type"), exports);
+__exportStar(require("./assertions/match-template"), exports);
+__exportStar(require("./assertions/and-assertion"), exports);
+__exportStar(require("./assertions/negated-assertion"), exports);
+__exportStar(require("./assertions/count-resources"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBNEI7QUFDNUIsd0RBQXNDO0FBQ3RDLDJDQUF5QjtBQUN6Qiw4Q0FBNEI7QUFDNUIsZ0RBQThCO0FBRTlCLHFEQUFtQztBQUNuQywyREFBeUM7QUFDekMsNkRBQTJDO0FBQzNDLHNFQUFvRDtBQUNwRCx5REFBdUM7QUFDdkMsOERBQTRDO0FBQzVDLDZEQUEyQztBQUMzQyxpRUFBK0M7QUFDL0MsK0RBQTZDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hc3NlcnRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9jYW5vbmljYWxpemUtYXNzZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vZXhwZWN0JztcbmV4cG9ydCAqIGZyb20gJy4vaW5zcGVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vc3ludGgtdXRpbHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Fzc2VydGlvbnMvZXhpc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NlcnRpb25zL2hhdmUtb3V0cHV0JztcbmV4cG9ydCAqIGZyb20gJy4vYXNzZXJ0aW9ucy9oYXZlLXJlc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vYXNzZXJ0aW9ucy9oYXZlLXJlc291cmNlLW1hdGNoZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vYXNzZXJ0aW9ucy9oYXZlLXR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NlcnRpb25zL21hdGNoLXRlbXBsYXRlJztcbmV4cG9ydCAqIGZyb20gJy4vYXNzZXJ0aW9ucy9hbmQtYXNzZXJ0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vYXNzZXJ0aW9ucy9uZWdhdGVkLWFzc2VydGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2Fzc2VydGlvbnMvY291bnQtcmVzb3VyY2VzJztcbiJdfQ==

package/node_modules/@aws-cdk/assert/lib/inspector.d.ts

@@ -0,0 +1,31 @@
+import * as api from 'aws-cdk-lib/cx-api';
+import { Assertion } from './assertion';
+import { MatchStyle } from './assertions/match-template';
+export declare abstract class Inspector {
+    aroundAssert?: (cb: () => void) => any;
+    constructor();
+    to(assertion: Assertion<this>): any;
+    notTo(assertion: Assertion<this>): any;
+    abstract get value(): any;
+    private _to;
+}
+export declare class StackInspector extends Inspector {
+    readonly stack: api.CloudFormationStackArtifact | object;
+    private readonly template;
+    constructor(stack: api.CloudFormationStackArtifact | object);
+    at(path: string | string[]): StackPathInspector;
+    toMatch(template: {
+        [key: string]: any;
+    }, matchStyle?: MatchStyle): any;
+    get value(): {
+        [key: string]: any;
+    };
+}
+export declare class StackPathInspector extends Inspector {
+    readonly stack: api.CloudFormationStackArtifact;
+    readonly path: string;
+    constructor(stack: api.CloudFormationStackArtifact, path: string);
+    get value(): {
+        [key: string]: any;
+    } | undefined;
+}

package/node_modules/@aws-cdk/assert/lib/inspector.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackPathInspector = exports.StackInspector = exports.Inspector = void 0;
+const cxschema = require("aws-cdk-lib/cloud-assembly-schema");
+const api = require("aws-cdk-lib/cx-api");
+const assertion_1 = require("./assertion");
+const match_template_1 = require("./assertions/match-template");
+class Inspector {
+    constructor() {
+        this.aroundAssert = undefined;
+    }
+    to(assertion) {
+        return this.aroundAssert ? this.aroundAssert(() => this._to(assertion))
+            : this._to(assertion);
+    }
+    notTo(assertion) {
+        return this.to(assertion_1.not(assertion));
+    }
+    _to(assertion) {
+        assertion.assertOrThrow(this);
+    }
+}
+exports.Inspector = Inspector;
+class StackInspector extends Inspector {
+    constructor(stack) {
+        super();
+        this.stack = stack;
+        this.template = stack instanceof api.CloudFormationStackArtifact ? stack.template : stack;
+    }
+    at(path) {
+        if (!(this.stack instanceof api.CloudFormationStackArtifact)) {
+            throw new Error('Cannot use "expect(stack).at(path)" for a raw template, only CloudFormationStackArtifact');
+        }
+        const strPath = typeof path === 'string' ? path : path.join('/');
+        return new StackPathInspector(this.stack, strPath);
+    }
+    toMatch(template, matchStyle = match_template_1.MatchStyle.EXACT) {
+        return this.to(match_template_1.matchTemplate(template, matchStyle));
+    }
+    get value() {
+        return this.template;
+    }
+}
+exports.StackInspector = StackInspector;
+class StackPathInspector extends Inspector {
+    constructor(stack, path) {
+        super();
+        this.stack = stack;
+        this.path = path;
+    }
+    get value() {
+        // The names of paths in metadata in tests are very ill-defined. Try with the full path first,
+        // then try with the stack name preprended for backwards compat with most tests that happen to give
+        // their stack an ID that's the same as the stack name.
+        const metadata = this.stack.manifest.metadata || {};
+        const md = metadata[this.path] || metadata[`/${this.stack.id}${this.path}`];
+        if (md === undefined) {
+            return undefined;
+        }
+        const resourceMd = md.find(entry => entry.type === cxschema.ArtifactMetadataEntryType.LOGICAL_ID);
+        if (resourceMd === undefined) {
+            return undefined;
+        }
+        const logicalId = resourceMd.data;
+        return this.stack.template.Resources[logicalId];
+    }
+}
+exports.StackPathInspector = StackPathInspector;
+//# sourceMappingURL=data:application/json;base64,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