### 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_
import base64
import datetime
import json
import logging
import re
import time
from enum import Enum
from typing import Any, Dict, Optional, Tuple, Union
from urllib.parse import urljoin
import pytz
import requests
from flask import Response as FlaskResponse
from jsonschema import ValidationError, validate
from moto.apigateway.models import apigateway_backends
from requests.models import Response
from localstack import config
from localstack.constants import (
    APPLICATION_JSON,
    HEADER_LOCALSTACK_EDGE_URL,
    LOCALHOST_HOSTNAME,
    PATH_USER_REQUEST,
    TEST_AWS_ACCOUNT_ID,
)
from localstack.services.apigateway import helpers
from localstack.services.apigateway.helpers import (