> **Experimental**
>
> `@aws-cdk/integ-tests-alpha` is an [**experimental**](/stability) (alpha) package: its API may change in any release, without a major version bump.
# InvocationType

The type of invocation.

Default is REQUEST_RESPONSE

- Stability: [Experimental](/cdk/api/stability.html)
- Source: [`lib/assertions/sdk.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/@aws-cdk/integ-tests-alpha/lib/assertions/sdk.ts#L179)

## Example

TypeScript:

```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:

```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:

```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")));
```

C# / .NET:

```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" }
}));
```

Golang:

```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

| Member | Description |
| --- | --- |
| `EVENT` | Invoke the function asynchronously. |
| `REQUEST_RESPONSE` | Invoke the function synchronously. |
| `DRY_RUN` | Validate parameter values and verify that the user or role has permission to invoke the function. |

## Referenced by

- [`LambdaInvokeFunctionProps`](/v2/docs/@aws-cdk_integ-tests-alpha.LambdaInvokeFunctionProps).invocationType
