@aws-amplify/graphql-api-construct 1.18.3-ai-next.0 → 1.18.3

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

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.annotateMatcher = exports.matcherFrom = exports.encodedJson = exports.Capture = exports.notMatching = exports.anything = exports.stringLike = exports.match = exports.failMatcher = exports.arrayWith = exports.exactValue = exports.deepObjectLike = exports.objectLike = void 0;
+const have_resource_1 = require("./have-resource");
+/**
+ * A matcher for an object that contains at least the given fields with the given matchers (or literals)
+ *
+ * Only does lenient matching one level deep, at the next level all objects must declare the
+ * exact expected keys again.
+ */
+function objectLike(pattern) {
+    return _objectContaining(pattern, false);
+}
+exports.objectLike = objectLike;
+/**
+ * A matcher for an object that contains at least the given fields with the given matchers (or literals)
+ *
+ * Switches to "deep" lenient matching. Nested objects also only need to contain declared keys.
+ */
+function deepObjectLike(pattern) {
+    return _objectContaining(pattern, true);
+}
+exports.deepObjectLike = deepObjectLike;
+function _objectContaining(pattern, deep) {
+    const anno = { [deep ? '$deepObjectLike' : '$objectLike']: pattern };
+    return annotateMatcher(anno, (value, inspection) => {
+        if (typeof value !== 'object' || !value) {
+            return failMatcher(inspection, `Expect an object but got '${typeof value}'`);
+        }
+        const errors = new Array();
+        for (const [patternKey, patternValue] of Object.entries(pattern)) {
+            if (patternValue === have_resource_1.ABSENT) {
+                if (value[patternKey] !== undefined) {
+                    errors.push(`Field ${patternKey} present, but shouldn't be`);
+                }
+                continue;
+            }
+            if (!(patternKey in value)) {
+                errors.push(`Field ${patternKey} missing`);
+                continue;
+            }
+            // If we are doing DEEP objectLike, translate object literals in the pattern into
+            // more `deepObjectLike` matchers, even if they occur in lists.
+            const matchValue = deep ? deepMatcherFromObjectLiteral(patternValue) : patternValue;
+            const innerInspection = { ...inspection, failureReason: '' };
+            const valueMatches = match(value[patternKey], matchValue, innerInspection);
+            if (!valueMatches) {
+                errors.push(`Field ${patternKey} mismatch: ${innerInspection.failureReason}`);
+            }
+        }
+        /**
+         * Transform nested object literals into more deep object matchers, if applicable
+         *
+         * Object literals in lists are also transformed.
+         */
+        function deepMatcherFromObjectLiteral(nestedPattern) {
+            if (isObject(nestedPattern)) {
+                return deepObjectLike(nestedPattern);
+            }
+            if (Array.isArray(nestedPattern)) {
+                return nestedPattern.map(deepMatcherFromObjectLiteral);
+            }
+            return nestedPattern;
+        }
+        if (errors.length > 0) {
+            return failMatcher(inspection, errors.join(', '));
+        }
+        return true;
+    });
+}
+/**
+ * Match exactly the given value
+ *
+ * This is the default, you only need this to escape from the deep lenient matching
+ * of `deepObjectLike`.
+ */
+function exactValue(expected) {
+    const anno = { $exactValue: expected };
+    return annotateMatcher(anno, (value, inspection) => {
+        return matchLiteral(value, expected, inspection);
+    });
+}
+exports.exactValue = exactValue;
+/**
+ * A matcher for a list that contains all of the given elements in any order
+ */
+function arrayWith(...elements) {
+    if (elements.length === 0) {
+        return anything();
+    }
+    const anno = { $arrayContaining: elements.length === 1 ? elements[0] : elements };
+    return annotateMatcher(anno, (value, inspection) => {
+        if (!Array.isArray(value)) {
+            return failMatcher(inspection, `Expect an array but got '${typeof value}'`);
+        }
+        for (const element of elements) {
+            const failure = longestFailure(value, element);
+            if (failure) {
+                return failMatcher(inspection, `Array did not contain expected element, closest match at index ${failure[0]}: ${failure[1]}`);
+            }
+        }
+        return true;
+        /**
+         * Return 'null' if the matcher matches anywhere in the array, otherwise the longest error and its index
+         */
+        function longestFailure(array, matcher) {
+            let fail = null;
+            for (let i = 0; i < array.length; i++) {
+                const innerInspection = { ...inspection, failureReason: '' };
+                if (match(array[i], matcher, innerInspection)) {
+                    return null;
+                }
+                if (fail === null || innerInspection.failureReason.length > fail[1].length) {
+                    fail = [i, innerInspection.failureReason];
+                }
+            }
+            return fail;
+        }
+    });
+}
+exports.arrayWith = arrayWith;
+/**
+ * Whether a value is an object
+ */
+function isObject(x) {
+    // Because `typeof null === 'object'`.
+    return x && typeof x === 'object';
+}
+/**
+ * Helper function to make matcher failure reporting a little easier
+ *
+ * Our protocol is weird (change a string on a passed-in object and return 'false'),
+ * but I don't want to change that right now.
+ */
+function failMatcher(inspection, error) {
+    inspection.failureReason = error;
+    return false;
+}
+exports.failMatcher = failMatcher;
+/**
+ * Match a given literal value against a matcher
+ *
+ * If the matcher is a callable, use that to evaluate the value. Otherwise, the values
+ * must be literally the same.
+ */
+function match(value, matcher, inspection) {
+    if (isCallable(matcher)) {
+        // Custom matcher (this mostly looks very weird because our `InspectionFailure` signature is weird)
+        const innerInspection = { ...inspection, failureReason: '' };
+        const result = matcher(value, innerInspection);
+        if (typeof result !== 'boolean') {
+            return failMatcher(inspection, `Predicate returned non-boolean return value: ${result}`);
+        }
+        if (!result && !innerInspection.failureReason) {
+            // Custom matcher neglected to return an error
+            return failMatcher(inspection, 'Predicate returned false');
+        }
+        // Propagate inner error in case of failure
+        if (!result) {
+            inspection.failureReason = innerInspection.failureReason;
+        }
+        return result;
+    }
+    return matchLiteral(value, matcher, inspection);
+}
+exports.match = match;
+/**
+ * Match a literal value at the top level.
+ *
+ * When recursing into arrays or objects, the nested values can be either matchers
+ * or literals.
+ */
+function matchLiteral(value, pattern, inspection) {
+    if (pattern == null) {
+        return true;
+    }
+    const errors = new Array();
+    if (Array.isArray(value) !== Array.isArray(pattern)) {
+        return failMatcher(inspection, 'Array type mismatch');
+    }
+    if (Array.isArray(value)) {
+        if (pattern.length !== value.length) {
+            return failMatcher(inspection, 'Array length mismatch');
+        }
+        // Recurse comparison for individual objects
+        for (let i = 0; i < pattern.length; i++) {
+            if (!match(value[i], pattern[i], { ...inspection })) {
+                errors.push(`Array element ${i} mismatch`);
+            }
+        }
+        if (errors.length > 0) {
+            return failMatcher(inspection, errors.join(', '));
+        }
+        return true;
+    }
+    if ((typeof value === 'object') !== (typeof pattern === 'object')) {
+        return failMatcher(inspection, 'Object type mismatch');
+    }
+    if (typeof pattern === 'object') {
+        // Check that all fields in the pattern have the right value
+        const innerInspection = { ...inspection, failureReason: '' };
+        const matcher = objectLike(pattern)(value, innerInspection);
+        if (!matcher) {
+            inspection.failureReason = innerInspection.failureReason;
+            return false;
+        }
+        // Check no fields uncovered
+        const realFields = new Set(Object.keys(value));
+        for (const key of Object.keys(pattern)) {
+            realFields.delete(key);
+        }
+        if (realFields.size > 0) {
+            return failMatcher(inspection, `Unexpected keys present in object: ${Array.from(realFields).join(', ')}`);
+        }
+        return true;
+    }
+    if (value !== pattern) {
+        return failMatcher(inspection, 'Different values');
+    }
+    return true;
+}
+/**
+ * Whether a value is a callable
+ */
+function isCallable(x) {
+    return x && {}.toString.call(x) === '[object Function]';
+}
+/**
+ * Do a glob-like pattern match (which only supports *s). Supports multiline strings.
+ */
+function stringLike(pattern) {
+    // Replace * with .* in the string, escape the rest and brace with ^...$
+    const regex = new RegExp(`^${pattern.split('*').map(escapeRegex).join('.*')}$`, 'm');
+    return annotateMatcher({ $stringContaining: pattern }, (value, failure) => {
+        if (typeof value !== 'string') {
+            failure.failureReason = `Expected a string, but got '${typeof value}'`;
+            return false;
+        }
+        if (!regex.test(value)) {
+            failure.failureReason = 'String did not match pattern';
+            return false;
+        }
+        return true;
+    });
+}
+exports.stringLike = stringLike;
+/**
+ * Matches any value
+ */
+function anything() {
+    return annotateMatcher({ $anything: true }, () => true);
+}
+exports.anything = anything;
+/**
+ * Negate an inner matcher
+ */
+function notMatching(matcher) {
+    return annotateMatcher({ $notMatching: matcher }, (value, failure) => {
+        const result = matcherFrom(matcher)(value, failure);
+        if (result) {
+            failure.failureReason = 'Should not have matched, but did';
+            return false;
+        }
+        return true;
+    });
+}
+exports.notMatching = notMatching;
+/**
+ * Captures a value onto an object if it matches a given inner matcher
+ *
+ * @example
+ *
+ * const someValue = Capture.aString();
+ * expect(stack).toHaveResource({
+ *    // ...
+ *    Value: someValue.capture(stringMatching('*a*')),
+ * });
+ * console.log(someValue.capturedValue);
+ */
+class Capture {
+    constructor(typeValidator) {
+        this.typeValidator = typeValidator;
+        this._didCapture = false;
+        this._wasInvoked = false;
+    }
+    /**
+     * A Capture object that captures any type
+     */
+    static anyType() {
+        return new Capture();
+    }
+    /**
+     * A Capture object that captures a string type
+     */
+    static aString() {
+        return new Capture((x) => {
+            if (typeof x !== 'string') {
+                throw new Error(`Expected to capture a string, got '${x}'`);
+            }
+            return true;
+        });
+    }
+    /**
+     * A Capture object that captures a custom type
+     */
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    static a(validator) {
+        return new Capture(validator);
+    }
+    /**
+     * Capture the value if the inner matcher successfully matches it
+     *
+     * If no matcher is given, `anything()` is assumed.
+     *
+     * And exception will be thrown if the inner matcher returns `true` and
+     * the value turns out to be of a different type than the `Capture` object
+     * is expecting.
+     */
+    capture(matcher) {
+        if (matcher === undefined) {
+            matcher = anything();
+        }
+        return annotateMatcher({ $capture: matcher }, (value, failure) => {
+            this._wasInvoked = true;
+            const result = matcherFrom(matcher)(value, failure);
+            if (result) {
+                if (this.typeValidator && !this.typeValidator(value)) {
+                    throw new Error(`Value not of the expected type: ${value}`);
+                }
+                this._didCapture = true;
+                this._value = value;
+            }
+            return result;
+        });
+    }
+    /**
+     * Whether a value was successfully captured
+     */
+    get didCapture() {
+        return this._didCapture;
+    }
+    /**
+     * Return the value that was captured
+     *
+     * Throws an exception if now value was captured
+     */
+    get capturedValue() {
+        // When this module is ported to jsii, the type parameter will obviously
+        // have to be dropped and this will have to turn into an `any`.
+        if (!this.didCapture) {
+            throw new Error(`Did not capture a value: ${this._wasInvoked ? 'inner matcher failed' : 'never invoked'}`);
+        }
+        return this._value;
+    }
+}
+exports.Capture = Capture;
+/**
+ * Match on the innards of a JSON string, instead of the complete string
+ */
+function encodedJson(matcher) {
+    return annotateMatcher({ $encodedJson: matcher }, (value, failure) => {
+        if (typeof value !== 'string') {
+            failure.failureReason = `Expected a string, but got '${typeof value}'`;
+            return false;
+        }
+        let decoded;
+        try {
+            decoded = JSON.parse(value);
+        }
+        catch (e) {
+            failure.failureReason = `String is not JSON: ${e}`;
+            return false;
+        }
+        return matcherFrom(matcher)(decoded, failure);
+    });
+}
+exports.encodedJson = encodedJson;
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+/**
+ * Make a matcher out of the given argument if it's not a matcher already
+ *
+ * If it's not a matcher, it will be treated as a literal.
+ */
+function matcherFrom(matcher) {
+    return isCallable(matcher) ? matcher : exactValue(matcher);
+}
+exports.matcherFrom = matcherFrom;
+/**
+ * Annotate a matcher with toJSON
+ *
+ * We will JSON.stringify() values if we have a match failure, but for matchers this
+ * would show (in traditional JS fashion) something like '[function Function]', or more
+ * accurately nothing at all since functions cannot be JSONified.
+ *
+ * We override to JSON() in order to produce a readable version of the matcher.
+ */
+function annotateMatcher(how, matcher) {
+    matcher.toJSON = () => how;
+    return matcher;
+}
+exports.annotateMatcher = annotateMatcher;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"have-resource-matchers.js","sourceRoot":"","sources":["have-resource-matchers.ts"],"names":[],"mappings":"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","sourcesContent":["import { ABSENT, InspectionFailure, PropertyMatcher } from './have-resource';\n\n/**\n * A matcher for an object that contains at least the given fields with the given matchers (or literals)\n *\n * Only does lenient matching one level deep, at the next level all objects must declare the\n * exact expected keys again.\n */\nexport function objectLike<A extends object>(pattern: A): PropertyMatcher {\n  return _objectContaining(pattern, false);\n}\n\n/**\n * A matcher for an object that contains at least the given fields with the given matchers (or literals)\n *\n * Switches to \"deep\" lenient matching. Nested objects also only need to contain declared keys.\n */\nexport function deepObjectLike<A extends object>(pattern: A): PropertyMatcher {\n  return _objectContaining(pattern, true);\n}\n\nfunction _objectContaining<A extends object>(pattern: A, deep: boolean): PropertyMatcher {\n  const anno = { [deep ? '$deepObjectLike' : '$objectLike']: pattern };\n\n  return annotateMatcher(anno, (value: any, inspection: InspectionFailure): boolean => {\n    if (typeof value !== 'object' || !value) {\n      return failMatcher(inspection, `Expect an object but got '${typeof value}'`);\n    }\n\n    const errors = new Array<string>();\n\n    for (const [patternKey, patternValue] of Object.entries(pattern)) {\n      if (patternValue === ABSENT) {\n        if (value[patternKey] !== undefined) { errors.push(`Field ${patternKey} present, but shouldn't be`); }\n        continue;\n      }\n\n      if (!(patternKey in value)) {\n        errors.push(`Field ${patternKey} missing`);\n        continue;\n      }\n\n      // If we are doing DEEP objectLike, translate object literals in the pattern into\n      // more `deepObjectLike` matchers, even if they occur in lists.\n      const matchValue = deep ? deepMatcherFromObjectLiteral(patternValue) : patternValue;\n\n      const innerInspection = { ...inspection, failureReason: '' };\n      const valueMatches = match(value[patternKey], matchValue, innerInspection);\n      if (!valueMatches) {\n        errors.push(`Field ${patternKey} mismatch: ${innerInspection.failureReason}`);\n      }\n    }\n\n    /**\n     * Transform nested object literals into more deep object matchers, if applicable\n     *\n     * Object literals in lists are also transformed.\n     */\n    function deepMatcherFromObjectLiteral(nestedPattern: any): any {\n      if (isObject(nestedPattern)) {\n        return deepObjectLike(nestedPattern);\n      }\n      if (Array.isArray(nestedPattern)) {\n        return nestedPattern.map(deepMatcherFromObjectLiteral);\n      }\n      return nestedPattern;\n    }\n\n    if (errors.length > 0) {\n      return failMatcher(inspection, errors.join(', '));\n    }\n    return true;\n  });\n}\n\n/**\n * Match exactly the given value\n *\n * This is the default, you only need this to escape from the deep lenient matching\n * of `deepObjectLike`.\n */\nexport function exactValue(expected: any): PropertyMatcher {\n  const anno = { $exactValue: expected };\n  return annotateMatcher(anno, (value: any, inspection: InspectionFailure): boolean => {\n    return matchLiteral(value, expected, inspection);\n  });\n}\n\n/**\n * A matcher for a list that contains all of the given elements in any order\n */\nexport function arrayWith(...elements: any[]): PropertyMatcher {\n  if (elements.length === 0) { return anything(); }\n\n  const anno = { $arrayContaining: elements.length === 1 ? elements[0] : elements };\n  return annotateMatcher(anno, (value: any, inspection: InspectionFailure): boolean => {\n    if (!Array.isArray(value)) {\n      return failMatcher(inspection, `Expect an array but got '${typeof value}'`);\n    }\n\n    for (const element of elements) {\n      const failure = longestFailure(value, element);\n      if (failure) {\n        return failMatcher(inspection, `Array did not contain expected element, closest match at index ${failure[0]}: ${failure[1]}`);\n      }\n    }\n\n    return true;\n\n    /**\n     * Return 'null' if the matcher matches anywhere in the array, otherwise the longest error and its index\n     */\n    function longestFailure(array: any[], matcher: any): [number, string] | null {\n      let fail: [number, string] | null = null;\n      for (let i = 0; i < array.length; i++) {\n        const innerInspection = { ...inspection, failureReason: '' };\n        if (match(array[i], matcher, innerInspection)) {\n          return null;\n        }\n\n        if (fail === null || innerInspection.failureReason.length > fail[1].length) {\n          fail = [i, innerInspection.failureReason];\n        }\n      }\n      return fail;\n    }\n  });\n}\n\n/**\n * Whether a value is an object\n */\nfunction isObject(x: any): x is object {\n  // Because `typeof null === 'object'`.\n  return x && typeof x === 'object';\n}\n\n/**\n * Helper function to make matcher failure reporting a little easier\n *\n * Our protocol is weird (change a string on a passed-in object and return 'false'),\n * but I don't want to change that right now.\n */\nexport function failMatcher(inspection: InspectionFailure, error: string): boolean {\n  inspection.failureReason = error;\n  return false;\n}\n\n/**\n * Match a given literal value against a matcher\n *\n * If the matcher is a callable, use that to evaluate the value. Otherwise, the values\n * must be literally the same.\n */\nexport function match(value: any, matcher: any, inspection: InspectionFailure) {\n  if (isCallable(matcher)) {\n    // Custom matcher (this mostly looks very weird because our `InspectionFailure` signature is weird)\n    const innerInspection: InspectionFailure = { ...inspection, failureReason: '' };\n    const result = matcher(value, innerInspection);\n    if (typeof result !== 'boolean') {\n      return failMatcher(inspection, `Predicate returned non-boolean return value: ${result}`);\n    }\n    if (!result && !innerInspection.failureReason) {\n      // Custom matcher neglected to return an error\n      return failMatcher(inspection, 'Predicate returned false');\n    }\n    // Propagate inner error in case of failure\n    if (!result) { inspection.failureReason = innerInspection.failureReason; }\n    return result;\n  }\n\n  return matchLiteral(value, matcher, inspection);\n}\n\n/**\n * Match a literal value at the top level.\n *\n * When recursing into arrays or objects, the nested values can be either matchers\n * or literals.\n */\nfunction matchLiteral(value: any, pattern: any, inspection: InspectionFailure) {\n  if (pattern == null) { return true; }\n\n  const errors = new Array<string>();\n\n  if (Array.isArray(value) !== Array.isArray(pattern)) {\n    return failMatcher(inspection, 'Array type mismatch');\n  }\n  if (Array.isArray(value)) {\n    if (pattern.length !== value.length) {\n      return failMatcher(inspection, 'Array length mismatch');\n    }\n\n    // Recurse comparison for individual objects\n    for (let i = 0; i < pattern.length; i++) {\n      if (!match(value[i], pattern[i], { ...inspection })) {\n        errors.push(`Array element ${i} mismatch`);\n      }\n    }\n\n    if (errors.length > 0) {\n      return failMatcher(inspection, errors.join(', '));\n    }\n    return true;\n  }\n  if ((typeof value === 'object') !== (typeof pattern === 'object')) {\n    return failMatcher(inspection, 'Object type mismatch');\n  }\n  if (typeof pattern === 'object') {\n    // Check that all fields in the pattern have the right value\n    const innerInspection = { ...inspection, failureReason: '' };\n    const matcher = objectLike(pattern)(value, innerInspection);\n    if (!matcher) {\n      inspection.failureReason = innerInspection.failureReason;\n      return false;\n    }\n\n    // Check no fields uncovered\n    const realFields = new Set(Object.keys(value));\n    for (const key of Object.keys(pattern)) { realFields.delete(key); }\n    if (realFields.size > 0) {\n      return failMatcher(inspection, `Unexpected keys present in object: ${Array.from(realFields).join(', ')}`);\n    }\n    return true;\n  }\n\n  if (value !== pattern) {\n    return failMatcher(inspection, 'Different values');\n  }\n\n  return true;\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 * Do a glob-like pattern match (which only supports *s). Supports multiline strings.\n */\nexport function stringLike(pattern: string): PropertyMatcher {\n  // Replace * with .* in the string, escape the rest and brace with ^...$\n  const regex = new RegExp(`^${pattern.split('*').map(escapeRegex).join('.*')}$`, 'm');\n\n  return annotateMatcher({ $stringContaining: pattern }, (value: any, failure: InspectionFailure) => {\n    if (typeof value !== 'string') {\n      failure.failureReason = `Expected a string, but got '${typeof value}'`;\n      return false;\n    }\n\n    if (!regex.test(value)) {\n      failure.failureReason = 'String did not match pattern';\n      return false;\n    }\n\n    return true;\n  });\n}\n\n/**\n * Matches any value\n */\nexport function anything(): PropertyMatcher {\n  return annotateMatcher({ $anything: true }, () => true);\n}\n\n/**\n * Negate an inner matcher\n */\nexport function notMatching(matcher: any): PropertyMatcher {\n  return annotateMatcher({ $notMatching: matcher }, (value: any, failure: InspectionFailure) => {\n    const result = matcherFrom(matcher)(value, failure);\n    if (result) {\n      failure.failureReason = 'Should not have matched, but did';\n      return false;\n    }\n    return true;\n  });\n}\n\nexport type TypeValidator<T> = (x: any) => x is T;\n\n/**\n * Captures a value onto an object if it matches a given inner matcher\n *\n * @example\n *\n * const someValue = Capture.aString();\n * expect(stack).toHaveResource({\n *    // ...\n *    Value: someValue.capture(stringMatching('*a*')),\n * });\n * console.log(someValue.capturedValue);\n */\nexport class Capture<T=any> {\n  /**\n   * A Capture object that captures any type\n   */\n  public static anyType(): Capture<any> {\n    return new Capture();\n  }\n\n  /**\n   * A Capture object that captures a string type\n   */\n  public static aString(): Capture<string> {\n    return new Capture((x: any): x is string => {\n      if (typeof x !== 'string') {\n        throw new Error(`Expected to capture a string, got '${x}'`);\n      }\n      return true;\n    });\n  }\n\n  /**\n   * A Capture object that captures a custom type\n   */\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  public static a<T>(validator: TypeValidator<T>): Capture<T> {\n    return new Capture(validator);\n  }\n\n  private _value?: T;\n  private _didCapture = false;\n  private _wasInvoked = false;\n\n  protected constructor(private readonly typeValidator?: TypeValidator<T>) {\n  }\n\n  /**\n   * Capture the value if the inner matcher successfully matches it\n   *\n   * If no matcher is given, `anything()` is assumed.\n   *\n   * And exception will be thrown if the inner matcher returns `true` and\n   * the value turns out to be of a different type than the `Capture` object\n   * is expecting.\n   */\n  public capture(matcher?: any): PropertyMatcher {\n    if (matcher === undefined) {\n      matcher = anything();\n    }\n\n    return annotateMatcher({ $capture: matcher }, (value: any, failure: InspectionFailure) => {\n      this._wasInvoked = true;\n      const result = matcherFrom(matcher)(value, failure);\n      if (result) {\n        if (this.typeValidator && !this.typeValidator(value)) {\n          throw new Error(`Value not of the expected type: ${value}`);\n        }\n        this._didCapture = true;\n        this._value = value;\n      }\n      return result;\n    });\n  }\n\n  /**\n   * Whether a value was successfully captured\n   */\n  public get didCapture() {\n    return this._didCapture;\n  }\n\n  /**\n   * Return the value that was captured\n   *\n   * Throws an exception if now value was captured\n   */\n  public get capturedValue(): T {\n    // When this module is ported to jsii, the type parameter will obviously\n    // have to be dropped and this will have to turn into an `any`.\n    if (!this.didCapture) {\n      throw new Error(`Did not capture a value: ${this._wasInvoked ? 'inner matcher failed' : 'never invoked'}`);\n    }\n    return this._value!;\n  }\n}\n\n/**\n * Match on the innards of a JSON string, instead of the complete string\n */\nexport function encodedJson(matcher: any): PropertyMatcher {\n  return annotateMatcher({ $encodedJson: matcher }, (value: any, failure: InspectionFailure) => {\n    if (typeof value !== 'string') {\n      failure.failureReason = `Expected a string, but got '${typeof value}'`;\n      return false;\n    }\n\n    let decoded;\n    try {\n      decoded = JSON.parse(value);\n    } catch (e) {\n      failure.failureReason = `String is not JSON: ${e}`;\n      return false;\n    }\n\n    return matcherFrom(matcher)(decoded, failure);\n  });\n}\n\nfunction escapeRegex(s: string) {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\n}\n\n/**\n * Make a matcher out of the given argument if it's not a matcher already\n *\n * If it's not a matcher, it will be treated as a literal.\n */\nexport function matcherFrom(matcher: any): PropertyMatcher {\n  return isCallable(matcher) ? matcher : exactValue(matcher);\n}\n\n/**\n * Annotate a matcher with toJSON\n *\n * We will JSON.stringify() values if we have a match failure, but for matchers this\n * would show (in traditional JS fashion) something like '[function Function]', or more\n * accurately nothing at all since functions cannot be JSONified.\n *\n * We override to JSON() in order to produce a readable version of the matcher.\n */\nexport function annotateMatcher<A extends object>(how: A, matcher: PropertyMatcher): PropertyMatcher {\n  (matcher as any).toJSON = () => how;\n  return matcher;\n}\n"]}

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

@@ -0,0 +1,69 @@
+import { Assertion, JestFriendlyAssertion } from '../assertion';
+import { StackInspector } from '../inspector';
+/**
+ * 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.
+ */
+export declare const 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.
+ */
+export declare function haveResource(resourceType: string, properties?: any, comparison?: ResourcePart, allowValueExtension?: boolean): Assertion<StackInspector>;
+/**
+ * Sugar for calling ``haveResource`` with ``allowValueExtension`` set to ``true``.
+ */
+export declare function haveResourceLike(resourceType: string, properties?: any, comparison?: ResourcePart): Assertion<StackInspector>;
+export declare type PropertyMatcher = (props: any, inspection: InspectionFailure) => boolean;
+export declare class HaveResourceAssertion extends JestFriendlyAssertion<StackInspector> {
+    private readonly resourceType;
+    private readonly inspected;
+    private readonly part;
+    private readonly matcher;
+    constructor(resourceType: string, properties?: any, part?: ResourcePart, allowValueExtension?: boolean);
+    assertUsing(inspector: StackInspector): boolean;
+    generateErrorMessage(): string;
+    assertOrThrow(inspector: StackInspector): void;
+    get description(): string;
+}
+export interface InspectionFailure {
+    resource: any;
+    failureReason: string;
+}
+/**
+ * What part of the resource to compare
+ */
+export declare enum ResourcePart {
+    /**
+     * Only compare the resource's properties
+     */
+    Properties = 0,
+    /**
+     * Check the entire CloudFormation config
+     *
+     * (including UpdateConfig, DependsOn, etc.)
+     */
+    CompleteDefinition = 1
+}
+/**
+ * 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.
+ */
+export declare function isSuperObject(superObj: any, pattern: any, errors?: string[], allowValueExtension?: boolean): boolean;