diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/asset.0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0.bundle/index.js b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/asset.0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0.bundle/index.js
new file mode 100644
index 0000000000000..22d251693c7ad
--- /dev/null
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/asset.0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0.bundle/index.js
@@ -0,0 +1,785 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/assertions/providers/lambda-handler/index.ts
+var lambda_handler_exports = {};
+__export(lambda_handler_exports, {
+  handler: () => handler,
+  isComplete: () => isComplete,
+  onTimeout: () => onTimeout
+});
+module.exports = __toCommonJS(lambda_handler_exports);
+
+// ../assertions/lib/matcher.ts
+var Matcher = class {
+  static isMatcher(x) {
+    return x && x instanceof Matcher;
+  }
+};
+var MatchResult = class {
+  constructor(target) {
+    this.failures = [];
+    this.captures = /* @__PURE__ */ new Map();
+    this.finalized = false;
+    this.target = target;
+  }
+  push(matcher, path, message) {
+    return this.recordFailure({ matcher, path, message });
+  }
+  recordFailure(failure) {
+    this.failures.push(failure);
+    return this;
+  }
+  hasFailed() {
+    return this.failures.length !== 0;
+  }
+  get failCount() {
+    return this.failures.length;
+  }
+  compose(id, inner) {
+    const innerF = inner.failures;
+    this.failures.push(...innerF.map((f) => {
+      return { path: [id, ...f.path], message: f.message, matcher: f.matcher };
+    }));
+    inner.captures.forEach((vals, capture) => {
+      vals.forEach((value) => this.recordCapture({ capture, value }));
+    });
+    return this;
+  }
+  finished() {
+    if (this.finalized) {
+      return this;
+    }
+    if (this.failCount === 0) {
+      this.captures.forEach((vals, cap) => cap._captured.push(...vals));
+    }
+    this.finalized = true;
+    return this;
+  }
+  toHumanStrings() {
+    return this.failures.map((r) => {
+      const loc = r.path.length === 0 ? "" : ` at ${r.path.join("")}`;
+      return "" + r.message + loc + ` (using ${r.matcher.name} matcher)`;
+    });
+  }
+  recordCapture(options) {
+    let values = this.captures.get(options.capture);
+    if (values === void 0) {
+      values = [];
+    }
+    values.push(options.value);
+    this.captures.set(options.capture, values);
+  }
+};
+
+// ../assertions/lib/private/matchers/absent.ts
+var AbsentMatch = class extends Matcher {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  test(actual) {
+    const result = new MatchResult(actual);
+    if (actual !== void 0) {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Received ${actual}, but key should be absent`
+      });
+    }
+    return result;
+  }
+};
+
+// ../assertions/lib/private/type.ts
+function getType(obj) {
+  return Array.isArray(obj) ? "array" : typeof obj;
+}
+
+// ../assertions/lib/match.ts
+var Match = class {
+  static absent() {
+    return new AbsentMatch("absent");
+  }
+  static arrayWith(pattern) {
+    return new ArrayMatch("arrayWith", pattern);
+  }
+  static arrayEquals(pattern) {
+    return new ArrayMatch("arrayEquals", pattern, { subsequence: false });
+  }
+  static exact(pattern) {
+    return new LiteralMatch("exact", pattern, { partialObjects: false });
+  }
+  static objectLike(pattern) {
+    return new ObjectMatch("objectLike", pattern);
+  }
+  static objectEquals(pattern) {
+    return new ObjectMatch("objectEquals", pattern, { partial: false });
+  }
+  static not(pattern) {
+    return new NotMatch("not", pattern);
+  }
+  static serializedJson(pattern) {
+    return new SerializedJson("serializedJson", pattern);
+  }
+  static anyValue() {
+    return new AnyMatch("anyValue");
+  }
+  static stringLikeRegexp(pattern) {
+    return new StringLikeRegexpMatch("stringLikeRegexp", pattern);
+  }
+};
+var LiteralMatch = class extends Matcher {
+  constructor(name, pattern, options = {}) {
+    super();
+    this.name = name;
+    this.pattern = pattern;
+    this.partialObjects = options.partialObjects ?? false;
+    if (Matcher.isMatcher(this.pattern)) {
+      throw new Error("LiteralMatch cannot directly contain another matcher. Remove the top-level matcher or nest it more deeply.");
+    }
+  }
+  test(actual) {
+    if (Array.isArray(this.pattern)) {
+      return new ArrayMatch(this.name, this.pattern, { subsequence: false, partialObjects: this.partialObjects }).test(actual);
+    }
+    if (typeof this.pattern === "object") {
+      return new ObjectMatch(this.name, this.pattern, { partial: this.partialObjects }).test(actual);
+    }
+    const result = new MatchResult(actual);
+    if (typeof this.pattern !== typeof actual) {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected type ${typeof this.pattern} but received ${getType(actual)}`
+      });
+      return result;
+    }
+    if (actual !== this.pattern) {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected ${this.pattern} but received ${actual}`
+      });
+    }
+    return result;
+  }
+};
+var ArrayMatch = class extends Matcher {
+  constructor(name, pattern, options = {}) {
+    super();
+    this.name = name;
+    this.pattern = pattern;
+    this.subsequence = options.subsequence ?? true;
+    this.partialObjects = options.partialObjects ?? false;
+  }
+  test(actual) {
+    if (!Array.isArray(actual)) {
+      return new MatchResult(actual).recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected type array but received ${getType(actual)}`
+      });
+    }
+    if (!this.subsequence && this.pattern.length !== actual.length) {
+      return new MatchResult(actual).recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected array of length ${this.pattern.length} but received ${actual.length}`
+      });
+    }
+    let patternIdx = 0;
+    let actualIdx = 0;
+    const result = new MatchResult(actual);
+    while (patternIdx < this.pattern.length && actualIdx < actual.length) {
+      const patternElement = this.pattern[patternIdx];
+      const matcher = Matcher.isMatcher(patternElement) ? patternElement : new LiteralMatch(this.name, patternElement, { partialObjects: this.partialObjects });
+      const matcherName = matcher.name;
+      if (this.subsequence && (matcherName == "absent" || matcherName == "anyValue")) {
+        throw new Error(`The Matcher ${matcherName}() cannot be nested within arrayWith()`);
+      }
+      const innerResult = matcher.test(actual[actualIdx]);
+      if (!this.subsequence || !innerResult.hasFailed()) {
+        result.compose(`[${actualIdx}]`, innerResult);
+        patternIdx++;
+        actualIdx++;
+      } else {
+        actualIdx++;
+      }
+    }
+    for (; patternIdx < this.pattern.length; patternIdx++) {
+      const pattern = this.pattern[patternIdx];
+      const element = Matcher.isMatcher(pattern) || typeof pattern === "object" ? " " : ` [${pattern}] `;
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Missing element${element}at pattern index ${patternIdx}`
+      });
+    }
+    return result;
+  }
+};
+var ObjectMatch = class extends Matcher {
+  constructor(name, pattern, options = {}) {
+    super();
+    this.name = name;
+    this.pattern = pattern;
+    this.partial = options.partial ?? true;
+  }
+  test(actual) {
+    if (typeof actual !== "object" || Array.isArray(actual)) {
+      return new MatchResult(actual).recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected type object but received ${getType(actual)}`
+      });
+    }
+    const result = new MatchResult(actual);
+    if (!this.partial) {
+      for (const a of Object.keys(actual)) {
+        if (!(a in this.pattern)) {
+          result.recordFailure({
+            matcher: this,
+            path: [`/${a}`],
+            message: "Unexpected key"
+          });
+        }
+      }
+    }
+    for (const [patternKey, patternVal] of Object.entries(this.pattern)) {
+      if (!(patternKey in actual) && !(patternVal instanceof AbsentMatch)) {
+        result.recordFailure({
+          matcher: this,
+          path: [`/${patternKey}`],
+          message: `Missing key '${patternKey}' among {${Object.keys(actual).join(",")}}`
+        });
+        continue;
+      }
+      const matcher = Matcher.isMatcher(patternVal) ? patternVal : new LiteralMatch(this.name, patternVal, { partialObjects: this.partial });
+      const inner = matcher.test(actual[patternKey]);
+      result.compose(`/${patternKey}`, inner);
+    }
+    return result;
+  }
+};
+var SerializedJson = class extends Matcher {
+  constructor(name, pattern) {
+    super();
+    this.name = name;
+    this.pattern = pattern;
+  }
+  test(actual) {
+    const result = new MatchResult(actual);
+    if (getType(actual) !== "string") {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected JSON as a string but found ${getType(actual)}`
+      });
+      return result;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(actual);
+    } catch (err) {
+      if (err instanceof SyntaxError) {
+        result.recordFailure({
+          matcher: this,
+          path: [],
+          message: `Invalid JSON string: ${actual}`
+        });
+        return result;
+      } else {
+        throw err;
+      }
+    }
+    const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern);
+    const innerResult = matcher.test(parsed);
+    result.compose(`(${this.name})`, innerResult);
+    return result;
+  }
+};
+var NotMatch = class extends Matcher {
+  constructor(name, pattern) {
+    super();
+    this.name = name;
+    this.pattern = pattern;
+  }
+  test(actual) {
+    const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern);
+    const innerResult = matcher.test(actual);
+    const result = new MatchResult(actual);
+    if (innerResult.failCount === 0) {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Found unexpected match: ${JSON.stringify(actual, void 0, 2)}`
+      });
+    }
+    return result;
+  }
+};
+var AnyMatch = class extends Matcher {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  test(actual) {
+    const result = new MatchResult(actual);
+    if (actual == null) {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: "Expected a value but found none"
+      });
+    }
+    return result;
+  }
+};
+var StringLikeRegexpMatch = class extends Matcher {
+  constructor(name, pattern) {
+    super();
+    this.name = name;
+    this.pattern = pattern;
+  }
+  test(actual) {
+    const result = new MatchResult(actual);
+    const regex = new RegExp(this.pattern, "gm");
+    if (typeof actual !== "string") {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `Expected a string, but got '${typeof actual}'`
+      });
+    }
+    if (!regex.test(actual)) {
+      result.recordFailure({
+        matcher: this,
+        path: [],
+        message: `String '${actual}' did not match pattern '${this.pattern}'`
+      });
+    }
+    return result;
+  }
+};
+
+// lib/assertions/providers/lambda-handler/base.ts
+var https = __toESM(require("https"));
+var url = __toESM(require("url"));
+var AWS = __toESM(require("aws-sdk"));
+var CustomResourceHandler = class {
+  constructor(event, context) {
+    this.event = event;
+    this.context = context;
+    this.timedOut = false;
+    this.timeout = setTimeout(async () => {
+      await this.respond({
+        status: "FAILED",
+        reason: "Lambda Function Timeout",
+        data: this.context.logStreamName
+      });
+      this.timedOut = true;
+    }, context.getRemainingTimeInMillis() - 1200);
+    this.event = event;
+    this.physicalResourceId = extractPhysicalResourceId(event);
+  }
+  async handle() {
+    try {
+      if ("stateMachineArn" in this.event.ResourceProperties) {
+        const req = {
+          stateMachineArn: this.event.ResourceProperties.stateMachineArn,
+          name: this.event.RequestId,
+          input: JSON.stringify(this.event)
+        };
+        await this.startExecution(req);
+        return;
+      } else {
+        const response = await this.processEvent(this.event.ResourceProperties);
+        return response;
+      }
+    } catch (e) {
+      console.log(e);
+      throw e;
+    } finally {
+      clearTimeout(this.timeout);
+    }
+  }
+  async handleIsComplete() {
+    try {
+      const result = await this.processEvent(this.event.ResourceProperties);
+      return result;
+    } catch (e) {
+      console.log(e);
+      return;
+    } finally {
+      clearTimeout(this.timeout);
+    }
+  }
+  async startExecution(req) {
+    try {
+      const sfn = new AWS.StepFunctions();
+      await sfn.startExecution(req).promise();
+    } finally {
+      clearTimeout(this.timeout);
+    }
+  }
+  respond(response) {
+    if (this.timedOut) {
+      return;
+    }
+    const cfResponse = {
+      Status: response.status,
+      Reason: response.reason,
+      PhysicalResourceId: this.physicalResourceId,
+      StackId: this.event.StackId,
+      RequestId: this.event.RequestId,
+      LogicalResourceId: this.event.LogicalResourceId,
+      NoEcho: false,
+      Data: response.data
+    };
+    const responseBody = JSON.stringify(cfResponse);
+    console.log("Responding to CloudFormation", responseBody);
+    const parsedUrl = url.parse(this.event.ResponseURL);
+    const requestOptions = {
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.path,
+      method: "PUT",
+      headers: { "content-type": "", "content-length": responseBody.length }
+    };
+    return new Promise((resolve, reject) => {
+      try {
+        const request2 = https.request(requestOptions, resolve);
+        request2.on("error", reject);
+        request2.write(responseBody);
+        request2.end();
+      } catch (e) {
+        reject(e);
+      } finally {
+        clearTimeout(this.timeout);
+      }
+    });
+  }
+};
+function extractPhysicalResourceId(event) {
+  switch (event.RequestType) {
+    case "Create":
+      return event.LogicalResourceId;
+    case "Update":
+    case "Delete":
+      return event.PhysicalResourceId;
+  }
+}
+
+// lib/assertions/providers/lambda-handler/assertion.ts
+var AssertionHandler = class extends CustomResourceHandler {
+  async processEvent(request2) {
+    let actual = decodeCall(request2.actual);
+    const expected = decodeCall(request2.expected);
+    let result;
+    const matcher = new MatchCreator(expected).getMatcher();
+    console.log(`Testing equality between ${JSON.stringify(request2.actual)} and ${JSON.stringify(request2.expected)}`);
+    const matchResult = matcher.test(actual);
+    matchResult.finished();
+    if (matchResult.hasFailed()) {
+      result = {
+        failed: true,
+        assertion: JSON.stringify({
+          status: "fail",
+          message: [
+            ...matchResult.toHumanStrings(),
+            JSON.stringify(matchResult.target, void 0, 2)
+          ].join("\n")
+        })
+      };
+      if (request2.failDeployment) {
+        throw new Error(result.assertion);
+      }
+    } else {
+      result = {
+        assertion: JSON.stringify({
+          status: "success"
+        })
+      };
+    }
+    return result;
+  }
+};
+var MatchCreator = class {
+  constructor(obj) {
+    this.parsedObj = {
+      matcher: obj
+    };
+  }
+  getMatcher() {
+    try {
+      const final = JSON.parse(JSON.stringify(this.parsedObj), function(_k, v) {
+        const nested = Object.keys(v)[0];
+        switch (nested) {
+          case "$ArrayWith":
+            return Match.arrayWith(v[nested]);
+          case "$ObjectLike":
+            return Match.objectLike(v[nested]);
+          case "$StringLike":
+            return Match.stringLikeRegexp(v[nested]);
+          case "$SerializedJson":
+            return Match.serializedJson(v[nested]);
+          default:
+            return v;
+        }
+      });
+      if (Matcher.isMatcher(final.matcher)) {
+        return final.matcher;
+      }
+      return Match.exact(final.matcher);
+    } catch {
+      return Match.exact(this.parsedObj.matcher);
+    }
+  }
+};
+function decodeCall(call) {
+  if (!call) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(call);
+    return parsed;
+  } catch (e) {
+    return call;
+  }
+}
+
+// lib/assertions/providers/lambda-handler/utils.ts
+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;
+    }
+  });
+}
+
+// lib/assertions/providers/lambda-handler/sdk.ts
+function flatten(object) {
+  return Object.assign(
+    {},
+    ...function _flatten(child, path = []) {
+      return [].concat(...Object.keys(child).map((key) => {
+        let childKey = Buffer.isBuffer(child[key]) ? child[key].toString("utf8") : child[key];
+        if (typeof childKey === "string") {
+          childKey = isJsonString(childKey);
+        }
+        return typeof childKey === "object" && childKey !== null ? _flatten(childKey, path.concat([key])) : { [path.concat([key]).join(".")]: childKey };
+      }));
+    }(object)
+  );
+}
+var AwsApiCallHandler = class extends CustomResourceHandler {
+  async processEvent(request2) {
+    const AWS2 = require("aws-sdk");
+    console.log(`AWS SDK VERSION: ${AWS2.VERSION}`);
+    if (!Object.prototype.hasOwnProperty.call(AWS2, request2.service)) {
+      throw Error(`Service ${request2.service} does not exist in AWS SDK version ${AWS2.VERSION}.`);
+    }
+    const service = new AWS2[request2.service]();
+    const response = await service[request2.api](request2.parameters && decode(request2.parameters)).promise();
+    console.log(`SDK response received ${JSON.stringify(response)}`);
+    delete response.ResponseMetadata;
+    const respond = {
+      apiCallResponse: response
+    };
+    const flatData = {
+      ...flatten(respond)
+    };
+    let resp = respond;
+    if (request2.outputPaths) {
+      resp = filterKeys(flatData, request2.outputPaths);
+    } else if (request2.flattenResponse === "true") {
+      resp = flatData;
+    }
+    console.log(`Returning result ${JSON.stringify(resp)}`);
+    return resp;
+  }
+};
+function filterKeys(object, searchStrings) {
+  return Object.entries(object).reduce((filteredObject, [key, value]) => {
+    for (const searchString of searchStrings) {
+      if (key.startsWith(`apiCallResponse.${searchString}`)) {
+        filteredObject[key] = value;
+      }
+    }
+    return filteredObject;
+  }, {});
+}
+function isJsonString(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// lib/assertions/providers/lambda-handler/types.ts
+var ASSERT_RESOURCE_TYPE = "Custom::DeployAssert@AssertEquals";
+var SDK_RESOURCE_TYPE_PREFIX = "Custom::DeployAssert@SdkCall";
+
+// lib/assertions/providers/lambda-handler/index.ts
+async function handler(event, context) {
+  console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`);
+  const provider = createResourceHandler(event, context);
+  try {
+    if (event.RequestType === "Delete") {
+      await provider.respond({
+        status: "SUCCESS",
+        reason: "OK"
+      });
+      return;
+    }
+    const result = await provider.handle();
+    if ("stateMachineArn" in event.ResourceProperties) {
+      console.info('Found "stateMachineArn", waiter statemachine started');
+      return;
+    } else if ("expected" in event.ResourceProperties) {
+      console.info('Found "expected", testing assertions');
+      const actualPath = event.ResourceProperties.actualPath;
+      const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse;
+      const assertion = new AssertionHandler({
+        ...event,
+        ResourceProperties: {
+          ServiceToken: event.ServiceToken,
+          actual,
+          expected: event.ResourceProperties.expected
+        }
+      }, context);
+      try {
+        const assertionResult = await assertion.handle();
+        await provider.respond({
+          status: "SUCCESS",
+          reason: "OK",
+          data: {
+            ...assertionResult,
+            ...result
+          }
+        });
+        return;
+      } catch (e) {
+        await provider.respond({
+          status: "FAILED",
+          reason: e.message ?? "Internal Error"
+        });
+        return;
+      }
+    }
+    await provider.respond({
+      status: "SUCCESS",
+      reason: "OK",
+      data: result
+    });
+  } catch (e) {
+    await provider.respond({
+      status: "FAILED",
+      reason: e.message ?? "Internal Error"
+    });
+    return;
+  }
+  return;
+}
+async function onTimeout(timeoutEvent) {
+  const isCompleteRequest = JSON.parse(JSON.parse(timeoutEvent.Cause).errorMessage);
+  const provider = createResourceHandler(isCompleteRequest, standardContext);
+  await provider.respond({
+    status: "FAILED",
+    reason: "Operation timed out: " + JSON.stringify(isCompleteRequest)
+  });
+}
+async function isComplete(event, context) {
+  console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`);
+  const provider = createResourceHandler(event, context);
+  try {
+    const result = await provider.handleIsComplete();
+    const actualPath = event.ResourceProperties.actualPath;
+    if (result) {
+      const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse;
+      if ("expected" in event.ResourceProperties) {
+        const assertion = new AssertionHandler({
+          ...event,
+          ResourceProperties: {
+            ServiceToken: event.ServiceToken,
+            actual,
+            expected: event.ResourceProperties.expected
+          }
+        }, context);
+        const assertionResult = await assertion.handleIsComplete();
+        if (!(assertionResult == null ? void 0 : assertionResult.failed)) {
+          await provider.respond({
+            status: "SUCCESS",
+            reason: "OK",
+            data: {
+              ...assertionResult,
+              ...result
+            }
+          });
+          return;
+        } else {
+          console.log(`Assertion Failed: ${JSON.stringify(assertionResult)}`);
+          throw new Error(JSON.stringify(event));
+        }
+      }
+      await provider.respond({
+        status: "SUCCESS",
+        reason: "OK",
+        data: result
+      });
+    } else {
+      console.log("No result");
+      throw new Error(JSON.stringify(event));
+    }
+    return;
+  } catch (e) {
+    console.log(e);
+    throw new Error(JSON.stringify(event));
+  }
+}
+function createResourceHandler(event, context) {
+  if (event.ResourceType.startsWith(SDK_RESOURCE_TYPE_PREFIX)) {
+    return new AwsApiCallHandler(event, context);
+  } else if (event.ResourceType.startsWith(ASSERT_RESOURCE_TYPE)) {
+    return new AssertionHandler(event, context);
+  } else {
+    throw new Error(`Unsupported resource type "${event.ResourceType}`);
+  }
+}
+var standardContext = {
+  getRemainingTimeInMillis: () => 9e4
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler,
+  isComplete,
+  onTimeout
+});
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/cdk.out b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/cdk.out
index 8ecc185e9dbee..145739f539580 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/cdk.out
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/cdk.out
@@ -1 +1 @@
-{"version":"21.0.0"}
\ No newline at end of file
+{"version":"22.0.0"}
\ No newline at end of file
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integ.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integ.json
index 5143272e39aa7..5c9c129e045e4 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integ.json
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integ.json
@@ -1,14 +1,12 @@
 {
-  "version": "21.0.0",
+  "version": "22.0.0",
   "testCases": {
-    "integ.lambda.docker": {
+    "integ/DefaultTest": {
       "stacks": [
         "lambda-ecr-docker"
       ],
-      "diffAssets": false,
-      "stackUpdateWorkflow": true
+      "assertionStack": "integ/DefaultTest/DeployAssert",
+      "assertionStackName": "integDefaultTestDeployAssert946684A0"
     }
-  },
-  "synthContext": {},
-  "enableLookups": false
+  }
 }
\ No newline at end of file
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integDefaultTestDeployAssert946684A0.assets.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integDefaultTestDeployAssert946684A0.assets.json
new file mode 100644
index 0000000000000..9c08ce2b347c5
--- /dev/null
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integDefaultTestDeployAssert946684A0.assets.json
@@ -0,0 +1,32 @@
+{
+  "version": "22.0.0",
+  "files": {
+    "0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0": {
+      "source": {
+        "path": "asset.0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0.bundle",
+        "packaging": "zip"
+      },
+      "destinations": {
+        "current_account-current_region": {
+          "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
+          "objectKey": "0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0.zip",
+          "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
+        }
+      }
+    },
+    "fc2d109d84a7a233f964621c7a788047bc94abc4b27920bc393068dd34eb2079": {
+      "source": {
+        "path": "integDefaultTestDeployAssert946684A0.template.json",
+        "packaging": "file"
+      },
+      "destinations": {
+        "current_account-current_region": {
+          "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
+          "objectKey": "fc2d109d84a7a233f964621c7a788047bc94abc4b27920bc393068dd34eb2079.json",
+          "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
+        }
+      }
+    }
+  },
+  "dockerImages": {}
+}
\ No newline at end of file
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integDefaultTestDeployAssert946684A0.template.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integDefaultTestDeployAssert946684A0.template.json
new file mode 100644
index 0000000000000..91689c42f6cd3
--- /dev/null
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/integDefaultTestDeployAssert946684A0.template.json
@@ -0,0 +1,178 @@
+{
+ "Resources": {
+  "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f": {
+   "Type": "Custom::DeployAssert@SdkCallLambdainvoke",
+   "Properties": {
+    "ServiceToken": {
+     "Fn::GetAtt": [
+      "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F",
+      "Arn"
+     ]
+    },
+    "service": "Lambda",
+    "api": "invoke",
+    "expected": "{\"$ObjectLike\":{\"Payload\":{\"$SerializedJson\":{\"statusCode\":200}}}}",
+    "parameters": {
+     "FunctionName": {
+      "Fn::ImportValue": "lambda-ecr-docker:ExportsOutputRefMyLambdaCCE802FBB974561C"
+     }
+    },
+    "flattenResponse": "false",
+    "salt": "1670351867329"
+   },
+   "UpdateReplacePolicy": "Delete",
+   "DeletionPolicy": "Delete"
+  },
+  "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5fInvokeCF29AB15": {
+   "Type": "AWS::Lambda::Permission",
+   "Properties": {
+    "Action": "lambda:InvokeFunction",
+    "FunctionName": {
+     "Fn::ImportValue": "lambda-ecr-docker:ExportsOutputRefMyLambdaCCE802FBB974561C"
+    },
+    "Principal": {
+     "Fn::GetAtt": [
+      "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73",
+      "Arn"
+     ]
+    }
+   }
+  },
+  "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73": {
+   "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": [
+        {
+         "Action": [
+          "lambda:Invoke"
+         ],
+         "Effect": "Allow",
+         "Resource": [
+          "*"
+         ]
+        },
+        {
+         "Action": [
+          "lambda:InvokeFunction"
+         ],
+         "Effect": "Allow",
+         "Resource": [
+          {
+           "Fn::Join": [
+            "",
+            [
+             "arn:",
+             {
+              "Ref": "AWS::Partition"
+             },
+             ":lambda:",
+             {
+              "Ref": "AWS::Region"
+             },
+             ":",
+             {
+              "Ref": "AWS::AccountId"
+             },
+             ":function:",
+             {
+              "Fn::ImportValue": "lambda-ecr-docker:ExportsOutputRefMyLambdaCCE802FBB974561C"
+             }
+            ]
+           ]
+          }
+         ]
+        }
+       ]
+      }
+     }
+    ]
+   }
+  },
+  "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F": {
+   "Type": "AWS::Lambda::Function",
+   "Properties": {
+    "Runtime": "nodejs14.x",
+    "Code": {
+     "S3Bucket": {
+      "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}"
+     },
+     "S3Key": "0ac341521855ed4705d41029b27ada812d7667cb8dcd05598acd18d5cc96b5a0.zip"
+    },
+    "Timeout": 120,
+    "Handler": "index.handler",
+    "Role": {
+     "Fn::GetAtt": [
+      "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73",
+      "Arn"
+     ]
+    }
+   }
+  }
+ },
+ "Outputs": {
+  "AssertionResultsLambdaInvoke8ca4d6356e56a59f578975a0656ecf5f": {
+   "Value": {
+    "Fn::GetAtt": [
+     "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f",
+     "assertion"
+    ]
+   }
+  }
+ },
+ "Parameters": {
+  "BootstrapVersion": {
+   "Type": "AWS::SSM::Parameter::Value<String>",
+   "Default": "/cdk-bootstrap/hnb659fds/version",
+   "Description": "Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]"
+  }
+ },
+ "Rules": {
+  "CheckBootstrapVersion": {
+   "Assertions": [
+    {
+     "Assert": {
+      "Fn::Not": [
+       {
+        "Fn::Contains": [
+         [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+         ],
+         {
+          "Ref": "BootstrapVersion"
+         }
+        ]
+       }
+      ]
+     },
+     "AssertDescription": "CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI."
+    }
+   ]
+  }
+ }
+}
\ No newline at end of file
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.assets.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.assets.json
index cf6569ac202f2..3b5cbd9972dab 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.assets.json
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.assets.json
@@ -1,7 +1,7 @@
 {
-  "version": "21.0.0",
+  "version": "22.0.0",
   "files": {
-    "077f5b1d65ef54f982550efd635d477a7884189645881cd41c11646212797905": {
+    "2c20f3551f9569b05a50288a76ab830f85c7d1482016211bf1ff4df621c7a215": {
       "source": {
         "path": "lambda-ecr-docker.template.json",
         "packaging": "file"
@@ -9,7 +9,7 @@
       "destinations": {
         "current_account-current_region": {
           "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
-          "objectKey": "077f5b1d65ef54f982550efd635d477a7884189645881cd41c11646212797905.json",
+          "objectKey": "2c20f3551f9569b05a50288a76ab830f85c7d1482016211bf1ff4df621c7a215.json",
           "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
         }
       }
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.template.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.template.json
index c7b044e6b049c..8fee0c3ad8db8 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.template.json
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/lambda-ecr-docker.template.json
@@ -52,6 +52,16 @@
    ]
   }
  },
+ "Outputs": {
+  "ExportsOutputRefMyLambdaCCE802FBB974561C": {
+   "Value": {
+    "Ref": "MyLambdaCCE802FB"
+   },
+   "Export": {
+    "Name": "lambda-ecr-docker:ExportsOutputRefMyLambdaCCE802FBB974561C"
+   }
+  }
+ },
  "Parameters": {
   "BootstrapVersion": {
    "Type": "AWS::SSM::Parameter::Value<String>",
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/manifest.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/manifest.json
index 6a7637f20b49f..04dc935377ca5 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/manifest.json
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/manifest.json
@@ -1,12 +1,6 @@
 {
-  "version": "21.0.0",
+  "version": "22.0.0",
   "artifacts": {
-    "Tree": {
-      "type": "cdk:tree",
-      "properties": {
-        "file": "tree.json"
-      }
-    },
     "lambda-ecr-docker.assets": {
       "type": "cdk:asset-manifest",
       "properties": {
@@ -23,7 +17,7 @@
         "validateOnSynth": false,
         "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-${AWS::Region}",
         "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-${AWS::Region}",
-        "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/077f5b1d65ef54f982550efd635d477a7884189645881cd41c11646212797905.json",
+        "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/2c20f3551f9569b05a50288a76ab830f85c7d1482016211bf1ff4df621c7a215.json",
         "requiresBootstrapStackVersion": 6,
         "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version",
         "additionalDependencies": [
@@ -51,6 +45,12 @@
             "data": "MyLambdaCCE802FB"
           }
         ],
+        "/lambda-ecr-docker/Exports/Output{\"Ref\":\"MyLambdaCCE802FB\"}": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "ExportsOutputRefMyLambdaCCE802FBB974561C"
+          }
+        ],
         "/lambda-ecr-docker/BootstrapVersion": [
           {
             "type": "aws:cdk:logicalId",
@@ -65,6 +65,90 @@
         ]
       },
       "displayName": "lambda-ecr-docker"
+    },
+    "integDefaultTestDeployAssert946684A0.assets": {
+      "type": "cdk:asset-manifest",
+      "properties": {
+        "file": "integDefaultTestDeployAssert946684A0.assets.json",
+        "requiresBootstrapStackVersion": 6,
+        "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version"
+      }
+    },
+    "integDefaultTestDeployAssert946684A0": {
+      "type": "aws:cloudformation:stack",
+      "environment": "aws://unknown-account/unknown-region",
+      "properties": {
+        "templateFile": "integDefaultTestDeployAssert946684A0.template.json",
+        "validateOnSynth": false,
+        "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-${AWS::Region}",
+        "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-${AWS::Region}",
+        "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/fc2d109d84a7a233f964621c7a788047bc94abc4b27920bc393068dd34eb2079.json",
+        "requiresBootstrapStackVersion": 6,
+        "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version",
+        "additionalDependencies": [
+          "integDefaultTestDeployAssert946684A0.assets"
+        ],
+        "lookupRole": {
+          "arn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-lookup-role-${AWS::AccountId}-${AWS::Region}",
+          "requiresBootstrapStackVersion": 8,
+          "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version"
+        }
+      },
+      "dependencies": [
+        "lambda-ecr-docker",
+        "integDefaultTestDeployAssert946684A0.assets"
+      ],
+      "metadata": {
+        "/integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/Default/Default": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f"
+          }
+        ],
+        "/integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/Invoke": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5fInvokeCF29AB15"
+          }
+        ],
+        "/integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/AssertionResults": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "AssertionResultsLambdaInvoke8ca4d6356e56a59f578975a0656ecf5f"
+          }
+        ],
+        "/integ/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Role": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "SingletonFunction1488541a7b23466481b69b4408076b81Role37ABCE73"
+          }
+        ],
+        "/integ/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Handler": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "SingletonFunction1488541a7b23466481b69b4408076b81HandlerCD40AE9F"
+          }
+        ],
+        "/integ/DefaultTest/DeployAssert/BootstrapVersion": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "BootstrapVersion"
+          }
+        ],
+        "/integ/DefaultTest/DeployAssert/CheckBootstrapVersion": [
+          {
+            "type": "aws:cdk:logicalId",
+            "data": "CheckBootstrapVersion"
+          }
+        ]
+      },
+      "displayName": "integ/DefaultTest/DeployAssert"
+    },
+    "Tree": {
+      "type": "cdk:tree",
+      "properties": {
+        "file": "tree.json"
+      }
     }
   }
 }
\ No newline at end of file
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/tree.json b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/tree.json
index 864a4d895c795..bee525ae0c695 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/tree.json
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.js.snapshot/tree.json
@@ -4,14 +4,6 @@
     "id": "App",
     "path": "",
     "children": {
-      "Tree": {
-        "id": "Tree",
-        "path": "Tree",
-        "constructInfo": {
-          "fqn": "constructs.Construct",
-          "version": "10.1.85"
-        }
-      },
       "lambda-ecr-docker": {
         "id": "lambda-ecr-docker",
         "path": "lambda-ecr-docker",
@@ -24,6 +16,14 @@
                 "id": "ServiceRole",
                 "path": "lambda-ecr-docker/MyLambda/ServiceRole",
                 "children": {
+                  "ImportServiceRole": {
+                    "id": "ImportServiceRole",
+                    "path": "lambda-ecr-docker/MyLambda/ServiceRole/ImportServiceRole",
+                    "constructInfo": {
+                      "fqn": "@aws-cdk/core.Resource",
+                      "version": "0.0.0"
+                    }
+                  },
                   "Resource": {
                     "id": "Resource",
                     "path": "lambda-ecr-docker/MyLambda/ServiceRole/Resource",
@@ -125,12 +125,204 @@
               "fqn": "@aws-cdk/aws-lambda.DockerImageFunction",
               "version": "0.0.0"
             }
+          },
+          "Exports": {
+            "id": "Exports",
+            "path": "lambda-ecr-docker/Exports",
+            "children": {
+              "Output{\"Ref\":\"MyLambdaCCE802FB\"}": {
+                "id": "Output{\"Ref\":\"MyLambdaCCE802FB\"}",
+                "path": "lambda-ecr-docker/Exports/Output{\"Ref\":\"MyLambdaCCE802FB\"}",
+                "constructInfo": {
+                  "fqn": "@aws-cdk/core.CfnOutput",
+                  "version": "0.0.0"
+                }
+              }
+            },
+            "constructInfo": {
+              "fqn": "constructs.Construct",
+              "version": "10.1.168"
+            }
+          },
+          "BootstrapVersion": {
+            "id": "BootstrapVersion",
+            "path": "lambda-ecr-docker/BootstrapVersion",
+            "constructInfo": {
+              "fqn": "@aws-cdk/core.CfnParameter",
+              "version": "0.0.0"
+            }
+          },
+          "CheckBootstrapVersion": {
+            "id": "CheckBootstrapVersion",
+            "path": "lambda-ecr-docker/CheckBootstrapVersion",
+            "constructInfo": {
+              "fqn": "@aws-cdk/core.CfnRule",
+              "version": "0.0.0"
+            }
           }
         },
         "constructInfo": {
           "fqn": "@aws-cdk/core.Stack",
           "version": "0.0.0"
         }
+      },
+      "integ": {
+        "id": "integ",
+        "path": "integ",
+        "children": {
+          "DefaultTest": {
+            "id": "DefaultTest",
+            "path": "integ/DefaultTest",
+            "children": {
+              "Default": {
+                "id": "Default",
+                "path": "integ/DefaultTest/Default",
+                "constructInfo": {
+                  "fqn": "constructs.Construct",
+                  "version": "10.1.168"
+                }
+              },
+              "DeployAssert": {
+                "id": "DeployAssert",
+                "path": "integ/DefaultTest/DeployAssert",
+                "children": {
+                  "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f": {
+                    "id": "LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f",
+                    "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f",
+                    "children": {
+                      "SdkProvider": {
+                        "id": "SdkProvider",
+                        "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/SdkProvider",
+                        "children": {
+                          "AssertionsProvider": {
+                            "id": "AssertionsProvider",
+                            "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/SdkProvider/AssertionsProvider",
+                            "constructInfo": {
+                              "fqn": "constructs.Construct",
+                              "version": "10.1.168"
+                            }
+                          }
+                        },
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/integ-tests.AssertionsProvider",
+                          "version": "0.0.0"
+                        }
+                      },
+                      "Default": {
+                        "id": "Default",
+                        "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/Default",
+                        "children": {
+                          "Default": {
+                            "id": "Default",
+                            "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/Default/Default",
+                            "constructInfo": {
+                              "fqn": "@aws-cdk/core.CfnResource",
+                              "version": "0.0.0"
+                            }
+                          }
+                        },
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/core.CustomResource",
+                          "version": "0.0.0"
+                        }
+                      },
+                      "Invoke": {
+                        "id": "Invoke",
+                        "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/Invoke",
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/core.CfnResource",
+                          "version": "0.0.0"
+                        }
+                      },
+                      "AssertionResults": {
+                        "id": "AssertionResults",
+                        "path": "integ/DefaultTest/DeployAssert/LambdaInvoke8ca4d6356e56a59f578975a0656ecf5f/AssertionResults",
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/core.CfnOutput",
+                          "version": "0.0.0"
+                        }
+                      }
+                    },
+                    "constructInfo": {
+                      "fqn": "@aws-cdk/integ-tests.LambdaInvokeFunction",
+                      "version": "0.0.0"
+                    }
+                  },
+                  "SingletonFunction1488541a7b23466481b69b4408076b81": {
+                    "id": "SingletonFunction1488541a7b23466481b69b4408076b81",
+                    "path": "integ/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81",
+                    "children": {
+                      "Staging": {
+                        "id": "Staging",
+                        "path": "integ/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Staging",
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/core.AssetStaging",
+                          "version": "0.0.0"
+                        }
+                      },
+                      "Role": {
+                        "id": "Role",
+                        "path": "integ/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Role",
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/core.CfnResource",
+                          "version": "0.0.0"
+                        }
+                      },
+                      "Handler": {
+                        "id": "Handler",
+                        "path": "integ/DefaultTest/DeployAssert/SingletonFunction1488541a7b23466481b69b4408076b81/Handler",
+                        "constructInfo": {
+                          "fqn": "@aws-cdk/core.CfnResource",
+                          "version": "0.0.0"
+                        }
+                      }
+                    },
+                    "constructInfo": {
+                      "fqn": "constructs.Construct",
+                      "version": "10.1.168"
+                    }
+                  },
+                  "BootstrapVersion": {
+                    "id": "BootstrapVersion",
+                    "path": "integ/DefaultTest/DeployAssert/BootstrapVersion",
+                    "constructInfo": {
+                      "fqn": "@aws-cdk/core.CfnParameter",
+                      "version": "0.0.0"
+                    }
+                  },
+                  "CheckBootstrapVersion": {
+                    "id": "CheckBootstrapVersion",
+                    "path": "integ/DefaultTest/DeployAssert/CheckBootstrapVersion",
+                    "constructInfo": {
+                      "fqn": "@aws-cdk/core.CfnRule",
+                      "version": "0.0.0"
+                    }
+                  }
+                },
+                "constructInfo": {
+                  "fqn": "@aws-cdk/core.Stack",
+                  "version": "0.0.0"
+                }
+              }
+            },
+            "constructInfo": {
+              "fqn": "@aws-cdk/integ-tests.IntegTestCase",
+              "version": "0.0.0"
+            }
+          }
+        },
+        "constructInfo": {
+          "fqn": "@aws-cdk/integ-tests.IntegTest",
+          "version": "0.0.0"
+        }
+      },
+      "Tree": {
+        "id": "Tree",
+        "path": "Tree",
+        "constructInfo": {
+          "fqn": "constructs.Construct",
+          "version": "10.1.168"
+        }
       }
     },
     "constructInfo": {
diff --git a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.ts b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.ts
index 3870d0cadf3b5..2cacbc8a27989 100644
--- a/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.ts
+++ b/packages/@aws-cdk/aws-lambda/test/integ.lambda.docker.ts
@@ -1,18 +1,31 @@
 import * as path from 'path';
 import { App, Stack } from '@aws-cdk/core';
-import { DockerImageCode, DockerImageFunction } from '../lib';
+import { ExpectedResult, IntegTest, Match } from '@aws-cdk/integ-tests';
+import { DockerImageCode, DockerImageFunction, Function } from '../lib';
 
 class TestStack extends Stack {
+  public fn: Function
   constructor(scope: App, id: string) {
     super(scope, id);
 
-    new DockerImageFunction(this, 'MyLambda', {
+    this.fn = new DockerImageFunction(this, 'MyLambda', {
       code: DockerImageCode.fromImageAsset(path.join(__dirname, 'docker-lambda-handler')),
     });
   }
 }
 
 const app = new App();
-new TestStack(app, 'lambda-ecr-docker');
+const testStack = new TestStack(app, 'lambda-ecr-docker');
+const integ = new IntegTest(app, 'integ', {
+  testCases: [testStack],
+});
 
-app.synth();
\ No newline at end of file
+const invoke = integ.assertions.invokeFunction({
+  functionName: testStack.fn.functionName,
+});
+
+invoke.expect(ExpectedResult.objectLike({
+  Payload: Match.serializedJson({ statusCode: 200 }),
+}));
+
+app.synth();