### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

I have a CDK deployment that creates API Gateway with a single POST endpoint, configured to proxy to SNS using AWS integration.
When I deploy with "cdk deploy" to AWS and then use curl/Postman to POST - everything works as expected.
When I deploy to localhost using "cdklocal deploy", the deployment works just fine, but POSTing to the endpoint returns the following error: 

```
Exception: API Gateway AWS integration action URI "arn:aws:apigateway:us-east-1:sns:path/000000000000/cdk--dev--event-topic", method "POST" not yet implemented
```

HTTP status code returned is 400 Bad Request


### Expected Behavior

I expected for the solution to work just like it does in AWS, forwarding API Gateway POST to SNS and returning 200.

### How are you starting LocalStack?

With the `localstack` script

### Steps To Reproduce

#### How are you starting localstack (e.g., `bin/localstack` command, arguments, or `docker-compose.yml`)

    export LOCALSTACK_API_KEY=<my-api-key>
    localstack start

#### Client commands (e.g., AWS SDK code snippet, or sequence of "awslocal" commands)

```typescript
import {Stack, StackProps, aws_apigateway as apigateway, aws_sns as sns, aws_iam as iam, Aws} from 'aws-cdk-lib';
import {Construct} from 'constructs';

import {Stage} from "./config";

interface Props extends StackProps {
    stage: Stage;
}

export class SourceGatewayStack extends Stack {
    constructor(scope: Construct, id: string, props: Props) {
        super(scope, id, props);

        const api = new apigateway.RestApi(this, `cdk--${props.stage}--source-api`, {
            deploy: true,
            deployOptions: {
                stageName: props.stage,
                loggingLevel: apigateway.MethodLoggingLevel.INFO,
                tracingEnabled: true
            }
        });

        const topic = new sns.Topic(this, `cdk--${props.stage}--event-topic`, {
            displayName: `Event Topic (${props.stage})`,
            topicName: `cdk--${props.stage}--event-topic`
        });

        const eventResource = api.root.addResource('event');
        const snsTopicIntegration = this.buildSnsTopicIntegration(topic);
        eventResource.addMethod('POST', snsTopicIntegration, {
            methodResponses: [{statusCode: "200"}, {statusCode: "400"}]
        });
    }

    private buildSnsTopicIntegration(topic: sns.Topic) {
        const gatewayExecutionRole = new iam.Role(this, "GatewayExecutionRole", {
            assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
            inlinePolicies: {
                "PublishMessagePolicy": new iam.PolicyDocument({
                    statements: [new iam.PolicyStatement({
                        actions: ["sns:Publish"],
                        resources: [topic.topicArn]
                    })]
                })
            }
        });

        return new apigateway.AwsIntegration({
            service: 'sns',
            integrationHttpMethod: 'POST',
            path: `${Aws.ACCOUNT_ID}/${topic.topicName}`,
            options: {
                credentialsRole: gatewayExecutionRole,
                passthroughBehavior: apigateway.PassthroughBehavior.NEVER,
                requestParameters: {
                    "integration.request.header.Content-Type": `'application/x-www-form-urlencoded'`,
                },
                requestTemplates: {
                    "application/json": `Action=Publish&TopicArn=$util.urlEncode('${topic.topicArn}')&Message=$util.urlEncode($input.body)`,
                },
                integrationResponses: [
                    {
                        statusCode: "200",
                        responseTemplates: {
                            "application/json": `{"status": "message published"}`,
                        },
                    },
                    {
                        statusCode: "400",
                        selectionPattern: "^\[Error\].*",
                        responseTemplates: {
                            "application/json": `{\"state\":\"error\",\"message\":\"$util.escapeJavaScript($input.path('$.errorMessage'))\"}`,
                        },
                    }
                ],
            }
        });
    }
}

```

This is the POST request to localstack:
```
curl --location --request POST 'http://localhost:4566/restapis/67o2r1jppd/dev/_user_request_/event' \
--header 'Content-Type: application/json' \
--data-raw '{
    "test": "data"
}
'
```

Response is:
```
{"Type": "User", "message": "Error invoking integration for API Gateway ID '67o2r1jppd': API Gateway AWS integration action URI \"arn:aws:apigateway:us-east-1:sns:path/000000000000/cdk--dev--event-topic\", method \"POST\" not yet implemented", "__type": "InvalidRequest"}
```

### Environment

```markdown
- OS: MacOS Monterey 12.1
- LocalStack: 0.14.0
```


### Anything else?

_No response_
return find_api_subentity_by_id(api_id, authorizer_id, "authorizers")
def normalize_authorizer(data):
    is_list = isinstance(data, list)
    entries = data if is_list else [data]
    for i in range(len(entries)):
        entry = common.clone(entries[i])
        
        entry["authorizerResultTtlInSeconds"] = int(entry.get("authorizerResultTtlInSeconds", 300))
        entries[i] = entry
    return entries if is_list else entries[0]
def get_authorizers(path):
    region_details = APIGatewayRegion.get()
    
    api_id = get_api_id_from_path(path)
    authorizer_id = get_authorizer_id_from_path(path)
    auth_list = region_details.authorizers.get(api_id) or []
    if authorizer_id:
        authorizer = _find_authorizer(api_id, authorizer_id)
        if authorizer is None:
            return make_error_response(
                "Authorizer not found: %s" % authorizer_id,
                code=404,
                error_type="NotFoundException",
            )
        return to_authorizer_response_json(api_id, authorizer)
    result = [to_authorizer_response_json(api_id, a) for a in auth_list]
    result = {"item": result}
    return result
def add_authorizer(path, data):