Skip to content
v2.277.0

Experimental

@aws-cdk/integ-tests-alpha is an experimental (alpha) package: its API may change in any release, without a major version bump.

InvocationType Enum ​

The type of invocation.

Default is REQUEST_RESPONSE

Example ​

ts
declare const app: App;
declare const stack: Stack;
declare const queue: sqs.Queue;
declare const fn: lambda.IFunction;

const integ = new IntegTest(app, 'Integ', {
  testCases: [stack],
});

integ.assertions.invokeFunction({
  functionName: fn.functionName,
  invocationType: InvocationType.EVENT,
  payload: JSON.stringify({ status: 'OK' }),
});

const message = integ.assertions.awsApiCall('SQS', 'receiveMessage', {
  QueueUrl: queue.queueUrl,
  WaitTimeSeconds: 20,
});

message.assertAtPath('Messages.0.Body', ExpectedResult.objectLike({
  requestContext: {
    condition: 'Success',
  },
  requestPayload: {
    status: 'OK',
  },
  responseContext: {
    statusCode: 200,
  },
  responsePayload: 'success',
}));
python
# app: App
# stack: Stack
# queue: sqs.Queue
# fn: lambda.IFunction


integ = IntegTest(app, "Integ",
    test_cases=[stack]
)

integ.assertions.invoke_function(
    function_name=fn.function_name,
    invocation_type=InvocationType.EVENT,
    payload=JSON.stringify({"status": "OK"})
)

message = integ.assertions.aws_api_call("SQS", "receiveMessage", {
    "QueueUrl": queue.queue_url,
    "WaitTimeSeconds": 20
})

message.assert_at_path("Messages.0.Body", ExpectedResult.object_like({
    "request_context": {
        "condition": "Success"
    },
    "request_payload": {
        "status": "OK"
    },
    "response_context": {
        "status_code": 200
    },
    "response_payload": "success"
}))
java
App app;
Stack stack;
Queue queue;
IFunction fn;


IntegTest integ = IntegTest.Builder.create(app, "Integ")
        .testCases(List.of(stack))
        .build();

integ.assertions.invokeFunction(LambdaInvokeFunctionProps.builder()
        .functionName(fn.getFunctionName())
        .invocationType(InvocationType.EVENT)
        .payload(JSON.stringify(Map.of("status", "OK")))
        .build());

IApiCall message = integ.assertions.awsApiCall("SQS", "receiveMessage", Map.of(
        "QueueUrl", queue.getQueueUrl(),
        "WaitTimeSeconds", 20));

message.assertAtPath("Messages.0.Body", ExpectedResult.objectLike(Map.of(
        "requestContext", Map.of(
                "condition", "Success"),
        "requestPayload", Map.of(
                "status", "OK"),
        "responseContext", Map.of(
                "statusCode", 200),
        "responsePayload", "success")));
csharp
// Install: dotnet add package Amazon.CDK.IntegTests.Alpha
App app;
Stack stack;
Queue queue;
IFunction fn;


var integ = new IntegTest(app, "Integ", new IntegTestProps {
    TestCases = new [] { stack }
});

integ.Assertions.InvokeFunction(new LambdaInvokeFunctionProps {
    FunctionName = fn.FunctionName,
    InvocationType = InvocationType.EVENT,
    Payload = JSON.Stringify(new Dictionary<string, string> { { "status", "OK" } })
});

var message = integ.Assertions.AwsApiCall("SQS", "receiveMessage", new Dictionary<string, object> {
    { "QueueUrl", queue.QueueUrl },
    { "WaitTimeSeconds", 20 }
});

message.AssertAtPath("Messages.0.Body", ExpectedResult.ObjectLike(new Dictionary<string, object> {
    { "requestContext", new Dictionary<string, string> {
        { "condition", "Success" }
    } },
    { "requestPayload", new Dictionary<string, string> {
        { "status", "OK" }
    } },
    { "responseContext", new Dictionary<string, int> {
        { "statusCode", 200 }
    } },
    { "responsePayload", "success" }
}));
go
// Install: go get github.com/aws/aws-cdk-go/awscdkintegtestsalpha/v2
var app App
var stack Stack
var queue Queue
var fn IFunction


integ := awscdkintegtestsalpha.NewIntegTest(app, jsii.String("Integ"), &IntegTestProps{
	TestCases: []Stack{
		stack,
	},
})

integ.Assertions.InvokeFunction(&LambdaInvokeFunctionProps{
	FunctionName: fn.FunctionName,
	InvocationType: awscdkintegtestsalpha.InvocationType_EVENT,
	Payload: jSON.stringify(map[string]*string{
		"status": jsii.String("OK"),
	}),
})

message := integ.Assertions.AwsApiCall(jsii.String("SQS"), jsii.String("receiveMessage"), map[string]interface{}{
	"QueueUrl": queue.queueUrl,
	"WaitTimeSeconds": jsii.Number(20),
})

message.AssertAtPath(jsii.String("Messages.0.Body"), awscdkintegtestsalpha.ExpectedResult_ObjectLike(map[string]interface{}{
	"requestContext": map[string]*string{
		"condition": jsii.String("Success"),
	},
	"requestPayload": map[string]*string{
		"status": jsii.String("OK"),
	},
	"responseContext": map[string]*f64{
		"statusCode": jsii.Number(200),
	},
	"responsePayload": jsii.String("success"),
}))

Members ​

MemberDescription
EVENTInvoke the function asynchronously.
REQUEST_RESPONSEInvoke the function synchronously.
DRY_RUNValidate parameter values and verify that the user or role has permission to invoke the function.

Referenced by ​