@aws-cdk/assert

Variables

• ABSENT

Functions

• annotateMatcher()
• anything()
• arrayWith()
• beASupersetOfTemplate()
• canonicalizeTemplate()
• countResources()
• countResourcesLike()
• deepObjectLike()
• encodedJson()
• exactlyMatchTemplate()
• exactValue()
• exist()
• expect()
• failMatcher()
• haveOutput()
• haveResource()
• haveResourceLike()
• haveType()
• isSuperObject()
• match()
• matcherFrom()
• matchTemplate()
• not()
• notMatching()
• objectLike()
• stringLike()

Classes

• AndAssertion

  • assertOrThrow()
  • assertUsing()
  • description
• Assertion

  • and()
  • assertOrThrow()
  • assertUsing()
  • description
• Capture

  • a()
  • anyType()
  • aString()
  • capture()
  • capturedValue
  • didCapture
• HaveResourceAssertion

  • assertOrThrow()
  • assertUsing()
  • description
  • generateErrorMessage()
• Inspector

  • aroundAssert
  • notTo()
  • to()
  • value
• JestFriendlyAssertion

  • generateErrorMessage()
• NegatedAssertion

  • assertUsing()
  • description
• StackInspector

  • at()
  • stack
  • toMatch()
  • value
• StackPathInspector

  • path
  • stack
  • value
• SynthUtils

  • subset()
  • synthesize()
  • toCloudFormation()

Interfaces

• HaveOutputProperties

  • exportName
  • outputName
  • outputValue
• InspectionFailure

  • failureReason
  • resource
• SubsetOptions

  • resourceTypes

Enums

• MatchStyle

  • EXACT
  • NO_REPLACES
  • SUPERSET
• ResourcePart

  • CompleteDefinition
  • Properties

Type Aliases

• PropertyMatcher
• TypeValidator

variable ABSENT

const ABSENT: string;

• 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.

function annotateMatcher

annotateMatcher: <A extends object>(
    how: A,
    matcher: PropertyMatcher
) => PropertyMatcher;

• 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 anything

anything: () => PropertyMatcher;

• Matches any value

function arrayWith

arrayWith: (...elements: any[]) => PropertyMatcher;

• A matcher for a list that contains all of the given elements in any order

function beASupersetOfTemplate

beASupersetOfTemplate: (template: {
    [key: string]: any;
}) => Assertion<StackInspector>;

function canonicalizeTemplate

canonicalizeTemplate: (template: any) => any;

• 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 countResources

countResources: (
    resourceType: string,
    count?: number
) => JestFriendlyAssertion<StackInspector>;

• An assertion to check whether a resource of a given type and with the given properties exists, disregarding properties

function countResourcesLike

countResourcesLike: (
    resourceType: string,
    count: number | undefined,
    props: any
) => Assertion<StackInspector>;

• An assertion to check whether a resource of a given type and with the given properties exists, considering properties

function deepObjectLike

deepObjectLike: <A extends object>(pattern: A) => PropertyMatcher;

• 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 encodedJson

encodedJson: (matcher: any) => PropertyMatcher;

• Match on the innards of a JSON string, instead of the complete string

function exactlyMatchTemplate

exactlyMatchTemplate: (template: {
    [key: string]: any;
}) => Assertion<StackInspector>;

function exactValue

exactValue: (expected: any) => PropertyMatcher;

• Match exactly the given value

  This is the default, you only need this to escape from the deep lenient matching of deepObjectLike.

function exist

exist: () => Assertion<StackPathInspector>;

function expect

expect: (
    stack: api.CloudFormationStackArtifact | cdk.Stack | Record<string, any>,
    skipValidation?: boolean
) => StackInspector;

function failMatcher

failMatcher: (inspection: InspectionFailure, error: string) => boolean;

• 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 haveOutput

haveOutput: (
    props: HaveOutputProperties
) => JestFriendlyAssertion<StackInspector>;

• An assertion to check whether Output with particular properties is present in a stack

  Parameter props

  properties of the Output that is being asserted against. Check ``HaveOutputProperties`` interface to get full list of available parameters

function haveResource

haveResource: (
    resourceType: string,
    properties?: any,
    comparison?: ResourcePart,
    allowValueExtension?: boolean
) => Assertion<StackInspector>;

• An assertion to check whether a resource of a given type and with the given properties exists, disregarding properties

  Parameter resourceType

  the type of the resource that is expected to be present.

  Parameter 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.

  Parameter comparison

  the entity that is being asserted against.

  Parameter 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 haveResourceLike

haveResourceLike: (
    resourceType: string,
    properties?: any,
    comparison?: ResourcePart
) => Assertion<StackInspector>;

• Sugar for calling ``haveResource`` with ``allowValueExtension`` set to ``true``.

function haveType

haveType: (type: string) => Assertion<StackPathInspector>;

function isSuperObject

isSuperObject: (
    superObj: any,
    pattern: any,
    errors?: string[],
    allowValueExtension?: boolean
) => boolean;

• 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 match

match: (value: any, matcher: any, inspection: InspectionFailure) => boolean;

• 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 matcherFrom

matcherFrom: (matcher: any) => PropertyMatcher;

• 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 matchTemplate

matchTemplate: (
    template: { [key: string]: any },
    matchStyle?: MatchStyle
) => Assertion<StackInspector>;

function not

not: <T extends Inspector>(assertion: Assertion<T>) => Assertion<T>;

function notMatching

notMatching: (matcher: any) => PropertyMatcher;

• Negate an inner matcher

function objectLike

objectLike: <A extends object>(pattern: A) => PropertyMatcher;

• 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 stringLike

stringLike: (pattern: string) => PropertyMatcher;

• Do a glob-like pattern match (which only supports *s). Supports multiline strings.

type PropertyMatcher

type PropertyMatcher = (props: any, inspection: InspectionFailure) => boolean;

type TypeValidator

type TypeValidator<T> = (x: any) => x is T;