def add_api_destination_authorization(destination, headers, event):
connection_arn = destination.get("ConnectionArn", "")
connection_name = re.search(r"connection\/([a-zA-Z0-9-_]+)\/",
connection_arn).group(1)
connection_region = extract_region_from_arn(connection_arn)
# Using backend directly due to boto hiding passwords, keys and secret values
event_backend = moto_events_backends.get(connection_region)
connection = event_backend.describe_connection(name=connection_name)
headers.update(auth_keys_from_connection(connection))
auth_parameters = connection.get("AuthParameters", {})
invocation_parameters = auth_parameters.get("InvocationHttpParameters")
endpoint = destination.get("InvocationEndpoint")
if invocation_parameters:
header_parameters = list_of_parameters_to_object(
invocation_parameters.get("HeaderParameters", []))
headers.update(header_parameters)
body_parameters = list_of_parameters_to_object(
invocation_parameters.get("BodyParameters", []))
event.update(body_parameters)
query_parameters = invocation_parameters.get("QueryStringParameters",
[])
query_object = list_of_parameters_to_object(query_parameters)
endpoint = add_query_params_to_url(endpoint, query_object)
return endpoint
def test_add_query_params_to_url():
tt = [
{
"uri": "http://localhost.localstack.cloud",
"query_params": {"param": "122323"},
"expected": "http://localhost.localstack.cloud?param=122323",
},
{
"uri": "http://localhost.localstack.cloud?foo=bar",
"query_params": {"param": "122323"},
"expected": "http://localhost.localstack.cloud?foo=bar¶m" "=122323",
},
{
"uri": "http://localhost.localstack.cloud/foo/bar",
"query_params": {"param": "122323"},
"expected": "http://localhost.localstack.cloud/foo/bar?param" "=122323",
},
{
"uri": "http://localhost.localstack.cloud/foo/bar?foo=bar",
"query_params": {"param": "122323"},
"expected": "http://localhost.localstack.cloud/foo/bar?foo=bar" "¶m=122323",
},
{
"uri": "http://localhost.localstack.cloud?foo=bar",
"query_params": {"foo": "bar"},
"expected": "http://localhost.localstack.cloud?foo=bar",
},
]
for t in tt:
result = add_query_params_to_url(t["uri"], t["query_params"])
assert result == t["expected"]
def add_http_parameters(http_parameters: Dict, endpoint: str, headers: Dict,
body):
headers.update(http_parameters.get("HeaderParameters", {}))
endpoint = add_path_parameters_to_url(
endpoint, http_parameters.get("PathParameterValues", []))
endpoint = add_query_params_to_url(
endpoint, http_parameters.get("QueryStringParameters", {}))
return endpoint
def auth_keys_from_connection(connection: Dict):
headers = {}
auth_type = connection.get("AuthorizationType").upper()
auth_parameters = connection.get("AuthParameters")
if auth_type == AUTH_BASIC:
basic_auth_parameters = auth_parameters.get("BasicAuthParameters", {})
username = basic_auth_parameters.get("Username", "")
password = basic_auth_parameters.get("Password", "")
auth = "Basic " + to_str(
base64.b64encode("{}:{}".format(username,
password).encode("ascii")))
headers.update({"authorization": auth})
if auth_type == AUTH_API_KEY:
api_key_parameters = auth_parameters.get("ApiKeyAuthParameters", {})
api_key_name = api_key_parameters.get("ApiKeyName", "")
api_key_value = api_key_parameters.get("ApiKeyValue", "")
headers.update({api_key_name: api_key_value})
if auth_type == AUTH_OAUTH:
oauth_parameters = auth_parameters.get("OAuthParameters", {})
oauth_method = oauth_parameters.get("HttpMethod")
oauth_http_parameters = oauth_parameters.get("OAuthHttpParameters", {})
oauth_endpoint = oauth_parameters.get("AuthorizationEndpoint", "")
query_object = list_of_parameters_to_object(
oauth_http_parameters.get("QueryStringParameters", []))
oauth_endpoint = add_query_params_to_url(oauth_endpoint, query_object)
client_parameters = oauth_parameters.get("ClientParameters", {})
client_id = client_parameters.get("ClientID", "")
client_secret = client_parameters.get("ClientSecret", "")
oauth_body = list_of_parameters_to_object(
oauth_http_parameters.get("BodyParameters", []))
oauth_body.update({
"client_id": client_id,
"client_secret": client_secret
})
oauth_header = list_of_parameters_to_object(
oauth_http_parameters.get("HeaderParameters", []))
oauth_result = requests.request(
method=oauth_method,
url=oauth_endpoint,
data=json.dumps(oauth_body),
headers=oauth_header,
)
oauth_data = json.loads(oauth_result.text)
token_type = oauth_data.get("token_type", "")
access_token = oauth_data.get("access_token", "")
auth_header = "{} {}".format(token_type, access_token)
headers.update({"authorization": auth_header})
return headers
def add_target_http_parameters(http_parameters: Dict, endpoint: str,
headers: Dict, body):
endpoint = add_path_parameters_to_url(
endpoint, http_parameters.get("PathParameterValues", []))
# The request should prioritze connection header/query parameters over target params if there is an overlap
query_params = http_parameters.get("QueryStringParameters", {})
prev_query_params = extract_query_string_params(endpoint)[1]
query_params.update(prev_query_params)
endpoint = add_query_params_to_url(endpoint, query_params)
target_headers = http_parameters.get("HeaderParameters", {})
for target_header in target_headers.keys():
if target_header not in headers:
headers.update({target_header: target_headers.get(target_header)})
return endpoint
def apply_request_parameters(uri: str, integration: Dict[str, Any],
path_params: Dict[str, str],
query_params: Dict[str, str]):
request_parameters = integration.get("requestParameters")
uri = uri or integration.get("uri") or integration.get(
"integrationUri") or ""
if request_parameters:
for key in path_params:
# check if path_params is present in the integration request parameters
request_param_key = f"integration.request.path.{key}"
request_param_value = f"method.request.path.{key}"
if request_parameters.get(
request_param_key) == request_param_value:
uri = uri.replace(f"{{{key}}}", path_params[key])
if integration.get("type") != "HTTP_PROXY" and request_parameters:
for key in query_params.copy():
request_query_key = f"integration.request.querystring.{key}"
request_param_val = f"method.request.querystring.{key}"
if request_parameters.get(request_query_key,
None) != request_param_val:
query_params.pop(key)
return add_query_params_to_url(uri, query_params)