### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

Beacuse we use localstack for alot of integration tests and we often need to mock some rest api I wanted to use the mock function of api gateway to make a simple rest api mock, but I cant get it to work properly. 

When calling my api i get a empty dictionary response:
```
curl http://localhost:4566/restapis/kiyhgeyswi/test/_user_request_/123-v
* Uses proxy env variable no_proxy == 'localhost'
*   Trying 127.0.0.1:4566...
* Connected to localhost (127.0.0.1) port 4566 (#0)
> GET /restapis/kiyhgeyswi/test/_user_request_/test HTTP/1.1
> Host: localhost:4566
> User-Agent: curl/7.79.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200
< Content-Type: application/json
< Content-Length: 2
< Access-Control-Allow-Origin: *
< Access-Control-Allow-Methods: HEAD,GET,PUT,POST,DELETE,OPTIONS,PATCH
< Access-Control-Allow-Headers: authorization,cache-control,content-length,content-md5,content-type,etag,location,x-amz-acl,x-amz-content-sha256,x-amz-date,x-amz-request-id,x-amz-security-token,x-amz-tagging,x-amz-target,x-amz-user-agent,x-amz-version-id,x-amzn-requestid,x-localstack-target,amz-sdk-invocation-id,amz-sdk-request
< Access-Control-Expose-Headers: etag,x-amz-version-id
< Connection: close
< date: Tue, 22 Feb 2022 08:29:28 GMT
< server: hypercorn-h11
<
{}
```

### Expected Behavior

It should respond with the mock response. When deploying the exact same api in aws a get this response:
```
curl https://$API_ID.execute-api.$REGION.amazonaws.com/dev/123
{
    "statusCode": 200,
    "id2": 123
}
```

### How are you starting LocalStack?

With a docker-compose file

### Steps To Reproduce

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

docker-compose up
```
  version: '3.3'
  services:
    localstack:
      image: localstack/localstack:latest
      container_name: localstack_tests5
      ports:
        - '4566:4566'
        - '4571:4571'
        - '8080:8080'
      environment:
        - DOCKER_HOST=unix:///var/run/docker.sock
        - SERVICES=kms,dynamodb,apigateway
        - DEBUG=1
        - DEFAULT_REGION=eu-west-1
        - DATA_DIR=/tmp/localstack/data
        - LAMBDA_EXECUTOR=local
        - KINESIS_PROVIDER=kinesalite
        - KMS_PROVIDER=local-kms
      volumes:
        - '/var/run/docker.sock:/var/run/docker.sock'
 ```

./create_mock_api.sh

 ```
#!/bin/bash
NAME=main
FILE=main.zip
HANDLER=main
REGION=us-east-1

#Create rest api
aws apigateway create-rest-api --region $REGION --name 'mockapi' --endpoint-url=http://localhost:4566

API_ID=$(aws apigateway get-rest-apis --query "items[?name==\`mockapi\`].id" --output text --region $REGION --endpoint-url=http://localhost:4566)
PARENT_RESOURCE_ID=$(aws apigateway get-resources --rest-api-id ${API_ID} --query 'items[0].id' --output text --region $REGION --endpoint-url=http://localhost:4566)

#Create resource associated with path
aws apigateway create-resource \
--region $REGION \
--rest-api-id $API_ID \
--parent-id $PARENT_RESOURCE_ID \
--path-part "{id}" \
--endpoint-url=http://localhost:4566

RESOURCEID=$(aws apigateway get-resources --rest-api-id $API_ID --region $REGION --endpoint-url=http://localhost:4566 --query 'items[?path==`/{id}`].id' --output text)

aws apigateway create-model \
--region $REGION \
--rest-api-id $API_ID \
--name Empty2 \
--content-type application/json \
--schema "{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\": \"Empty Schema2\", \"type\": \"object\" }" \
--endpoint-url=http://localhost:4566

#Create get method and method response
aws apigateway put-method \
--region $REGION \
--rest-api-id $API_ID \
--resource-id $RESOURCEID \
--http-method GET \
--authorization-type "NONE" \
--request-parameters "method.request.path.id=true" \
--endpoint-url=http://localhost:4566

aws apigateway put-method-response \
--region $REGION \
--rest-api-id $API_ID \
--resource-id $RESOURCEID \
--http-method GET \
--status-code 200 \
--response-models "application/json=Empty2" \
--endpoint-url=http://localhost:4566

#Integrate api
aws apigateway put-integration \
--region $REGION \
--rest-api-id $API_ID \
--resource-id $RESOURCEID \
--http-method GET \
--type MOCK \
--passthrough-behavior WHEN_NO_MATCH \
--request-templates '{ "application/json": "{\"statusCode\": 200}" }' \
--endpoint-url=http://localhost:4566

aws apigateway put-integration-response \
--region $REGION \
--rest-api-id $API_ID \
--resource-id $RESOURCEID \
--http-method GET \
--status-code 200 \
--response-templates '{"application/json": "{\"statusCode\": 200,\"id2\": $input.params().path.id}"}' \
--endpoint-url=http://localhost:4566

#deploy
aws apigateway create-deployment \
 --region $REGION \
 --rest-api-id $API_ID \
 --stage-name test \
 --endpoint-url=http://localhost:4566
 
curl http://localhost:4566/restapis/${API_ID}/test/_user_request_/test -v
 ```

### Environment

```markdown
- OS: Windows 10
- LocalStack:  0.14.0 (latest/9cfaf4f1c73a)
```


### Anything else?

_No response_
headers = aws_stack.mock_aws_request_headers(
                service="kinesis", region_name=invocation_context.region_name
            )
            headers["X-Amz-Target"] = target
            result = common.make_http_request(
                url=config.service_url("kineses"), data=payload, headers=headers, method="POST"
            )
            
            result = apply_request_response_templates(
                result, response_templates, content_type=APPLICATION_JSON
            )
            return result
        elif "states:action/" in uri:
            action = uri.split("/")[-1]
            if APPLICATION_JSON in integration.get("requestTemplates", {}):
                payload = apply_request_response_templates(
                    data,
                    integration.get("requestTemplates"),
                    content_type=APPLICATION_JSON,
                    as_json=True,
                )
            else:
                payload = json.loads(data.decode("utf-8"))
            client = aws_stack.connect_to_service("stepfunctions")
            if isinstance(payload.get("input"), dict):
                payload["input"] = json.dumps(payload["input"])
            
            method_name = (
                camel_to_snake_case(action) if action != "StartSyncExecution" else "start_execution"