def test_yaml_with_tags(self):
output = yaml_parse(self.yaml_with_tags)
self.assertEquals(self.parsed_yaml_dict, output)
# Make sure formatter and parser work well with each other
formatted_str = yaml_dump(output)
output_again = yaml_parse(formatted_str)
self.assertEquals(output, output_again)
def test_yaml_with_tags(self):
output = yaml_parse(self.yaml_with_tags)
self.assertEquals(self.parsed_yaml_dict, output)
# Make sure formatter and parser work well with each other
formatted_str = yaml_dump(output)
output_again = yaml_parse(formatted_str)
self.assertEquals(output, output_again)
def _download_swagger(self, location):
"""
Download the file from given local or remote location and return it
Parameters
----------
location : str or dict
Local path or S3 path to Swagger file to download. Consult the ``__init__.py`` documentation for specifics
on structure of this property.
Returns
-------
dict or None
Downloaded and parsed Swagger document. None, if unable to download
"""
if not location:
return
bucket, key, version = self._parse_s3_location(location)
if bucket and key:
LOG.debug(
"Downloading Swagger document from Bucket=%s, Key=%s, Version=%s",
bucket, key, version)
swagger_str = self._download_from_s3(bucket, key, version)
return yaml_parse(swagger_str)
if not isinstance(location, string_types):
# This is not a string and not a S3 Location dictionary. Probably something invalid
LOG.debug("Unable to download Swagger file. Invalid location: %s",
location)
return
# ``location`` is a string and not a S3 path. It is probably a local path. Let's resolve relative path if any
filepath = location
if self.working_dir:
# Resolve relative paths, if any, with respect to working directory
filepath = os.path.join(self.working_dir, location)
if not os.path.exists(filepath):
LOG.debug(
"Unable to download Swagger file. File not found at location %s",
filepath)
return
LOG.debug("Reading Swagger document from local file at %s", filepath)
with open(filepath, "r") as fp:
return yaml_parse(fp.read())
def __init__(
self,
template_path: str,
parent_dir: str,
uploaders: Uploaders,
code_signer: CodeSigner,
resources_to_export=frozenset(
RESOURCES_EXPORT_LIST +
[CloudFormationStackResource, ServerlessApplicationResource]),
metadata_to_export=frozenset(METADATA_EXPORT_LIST),
):
"""
Reads the template and makes it ready for export
"""
if not (is_local_folder(parent_dir) and os.path.isabs(parent_dir)):
raise ValueError(
"parent_dir parameter must be "
"an absolute path to a folder {0}".format(parent_dir))
abs_template_path = make_abs_path(parent_dir, template_path)
template_dir = os.path.dirname(abs_template_path)
with open(abs_template_path, "r") as handle:
template_str = handle.read()
self.template_dict = yaml_parse(template_str)
self.template_dir = template_dir
self.resources_to_export = resources_to_export
self.metadata_to_export = metadata_to_export
self.uploaders = uploaders
self.code_signer = code_signer
def test_parse_yaml_preserve_elements_order(self):
input_template = ("B_Resource:\n"
" Key2:\n"
" Name: name2\n"
" Key1:\n"
" Name: name1\n"
"A_Resource:\n"
" Key2:\n"
" Name: name2\n"
" Key1:\n"
" Name: name1\n")
output_dict = yaml_parse(input_template)
expected_dict = OrderedDict([
("B_Resource",
OrderedDict([("Key2", {
"Name": "name2"
}), ("Key1", {
"Name": "name1"
})])),
("A_Resource",
OrderedDict([("Key2", {
"Name": "name2"
}), ("Key1", {
"Name": "name1"
})])),
])
self.assertEqual(expected_dict, output_dict)
output_template = yaml_dump(output_dict)
self.assertEqual(input_template, output_template)
def _verify_resource_property(self, template_path, logical_id, property, expected_value):
with open(template_path, "r") as fp:
template_dict = yaml_parse(fp.read())
self.assertEqual(
expected_value, jmespath.search(f"Resources.{logical_id}.Properties.{property}", template_dict)
)
def _verify_resource_property(self, template_path, logical_id, property,
expected_value):
with open(template_path, 'r') as fp:
template_dict = yaml_parse(fp.read())
self.assertEquals(
expected_value,
template_dict["Resources"][logical_id]["Properties"][property])
def run(self):
# Parse parameters
with open(self.template_file, "r") as handle:
template_str = handle.read()
template_dict = yaml_parse(template_str)
if not isinstance(template_dict, dict):
raise deploy_exceptions.DeployFailedError(
stack_name=self.stack_name, msg="{} not in required format".format(self.template_file)
)
parameters = self.merge_parameters(template_dict, self.parameter_overrides)
template_size = os.path.getsize(self.template_file)
if template_size > 51200 and not self.s3_bucket:
raise deploy_exceptions.DeployBucketRequiredError()
boto_config = get_boto_config_with_user_agent()
cloudformation_client = boto3.client(
"cloudformation", region_name=self.region if self.region else None, config=boto_config
)
s3_client = None
if self.s3_bucket:
s3_client = boto3.client("s3", region_name=self.region if self.region else None, config=boto_config)
self.s3_uploader = S3Uploader(
s3_client, self.s3_bucket, self.s3_prefix, self.kms_key_id, self.force_upload, self.no_progressbar
)
self.deployer = Deployer(cloudformation_client)
region = s3_client._client_config.region_name if s3_client else self.region # pylint: disable=W0212
print_deploy_args(
self.stack_name,
self.s3_bucket,
self.image_repository,
region,
self.capabilities,
self.parameter_overrides,
self.confirm_changeset,
self.signing_profiles,
)
return self.deploy(
self.stack_name,
template_str,
parameters,
self.capabilities,
self.no_execute_changeset,
self.role_arn,
self.notification_arns,
self.s3_uploader,
[{"Key": key, "Value": value} for key, value in self.tags.items()] if self.tags else [],
region,
self.fail_on_empty_changeset,
self.confirm_changeset,
)
def test_yaml_merge_tag(self):
test_yaml = """
base: &base
property: value
test:
<<: *base
"""
output = yaml_parse(test_yaml)
self.assertTrue(isinstance(output, OrderedDict))
self.assertEqual(output.get("test").get("property"), "value")
def test_valid_api_request_model_template(self, template_path):
with open(template_path) as f:
template = yamlhelper.yaml_parse(f.read())
managed_policy_mock = Mock()
managed_policy_mock.load.return_value = {"PolicyName": "FakePolicy"}
validator = SamTemplateValidator(template, managed_policy_mock)
# Should not throw an exception
validator.is_valid()
def _download_swagger(self, location):
"""
Download the file from given local or remote location and return it
Parameters
----------
location : str or dict
Local path or S3 path to Swagger file to download. Consult the ``__init__.py`` documentation for specifics
on structure of this property.
Returns
-------
dict or None
Downloaded and parsed Swagger document. None, if unable to download
"""
if not location:
return
bucket, key, version = self._parse_s3_location(location)
if bucket and key:
LOG.debug("Downloading Swagger document from Bucket=%s, Key=%s, Version=%s", bucket, key, version)
swagger_str = self._download_from_s3(bucket, key, version)
return yaml_parse(swagger_str)
if not isinstance(location, string_types):
# This is not a string and not a S3 Location dictionary. Probably something invalid
LOG.debug("Unable to download Swagger file. Invalid location: %s", location)
return
# ``location`` is a string and not a S3 path. It is probably a local path. Let's resolve relative path if any
filepath = location
if self.working_dir:
# Resolve relative paths, if any, with respect to working directory
filepath = os.path.join(self.working_dir, location)
if not os.path.exists(filepath):
LOG.debug("Unable to download Swagger file. File not found at location %s", filepath)
return
LOG.debug("Reading Swagger document from local file at %s", filepath)
with open(filepath, "r") as fp:
return yaml_parse(fp.read())
def test_yaml_getatt(self):
# This is an invalid syntax for !GetAtt. But make sure the code does not crash when we encouter this syntax
# Let CloudFormation interpret this value at runtime
input = """
Resource:
Key: !GetAtt ["a", "b"]
"""
output = {"Resource": {"Key": {"Fn::GetAtt": ["a", "b"]}}}
actual_output = yaml_parse(input)
self.assertEquals(actual_output, output)
def test_warning_check(self, template_txt, expected_warning_msg, message_present):
if template_txt:
template_dict = yaml_parse(template_txt)
else:
template_dict = None
current_warning_checker = TemplateWarningsChecker()
actual_warning_msg = current_warning_checker.check_template_for_warning(
CodeDeployWarning.__name__, template_dict
)
if not message_present:
self.assertIsNone(actual_warning_msg)
else:
self.assertEqual(expected_warning_msg, actual_warning_msg)
def get_template_data(template_file):
"""
Read the template file, parse it as JSON/YAML and return the template as a dictionary.
:param string template_file: Path to the template to read
:return dict: Template data as a dictionary
"""
if not pathlib.Path(template_file).exists():
raise ValueError("Template file not found at {}".format(template_file))
with open(template_file, 'r') as fp:
try:
return yaml_parse(fp.read())
except (ValueError, yaml.YAMLError) as ex:
raise ValueError("Failed to parse template: {}".format(str(ex)))
def _read_sam_file(template):
"""
Reads the file (json and yaml supported) provided and returns the dictionary representation of the file.
:param str template: Path to the template file
:return dict: Dictionary representing the SAM Template
:raises: SamTemplateNotFoundException when the template file does not exist
"""
if not os.path.exists(template):
click.secho("SAM Template Not Found", bg='red')
raise SamTemplateNotFoundException("Template at {} is not found".format(template))
with click.open_file(template, 'r') as sam_template:
sam_template = yaml_parse(sam_template.read())
return sam_template
def _read_sam_file(template):
"""
Reads the file (json and yaml supported) provided and returns the dictionary representation of the file.
:param str template: Path to the template file
:return dict: Dictionary representing the SAM Template
:raises: SamTemplateNotFoundException when the template file does not exist
"""
if not os.path.exists(template):
click.secho("SAM Template Not Found", bg='red')
raise SamTemplateNotFoundException("Template at {} is not found".format(template))
with click.open_file(template, 'r') as sam_template:
sam_template = yaml_parse(sam_template.read())
return sam_template
def _get_template_data(template_file):
"""
Read the template file, parse it as JSON/YAML and return the template as a dictionary.
:param string template_file: Path to the template to read
:return dict: Template data as a dictionary
:raises InvokeContextException: If template file was not found or the data was not a JSON/YAML
"""
if not os.path.exists(template_file):
raise InvokeContextException("Template file not found at {}".format(template_file))
with open(template_file, 'r') as fp:
try:
return yaml_parse(fp.read())
except (ValueError, yaml.YAMLError) as ex:
raise InvokeContextException("Failed to parse template: {}".format(str(ex)))
def test_yaml_getatt(self):
# This is an invalid syntax for !GetAtt. But make sure the code does not crash when we encouter this syntax
# Let CloudFormation interpret this value at runtime
input = """
Resource:
Key: !GetAtt ["a", "b"]
"""
output = {
"Resource": {
"Key": {
"Fn::GetAtt": ["a", "b"]
}
}
}
actual_output = yaml_parse(input)
self.assertEquals(actual_output, output)
def _read_sam_file(template):
"""
Reads the file (json and yaml supported) provided and returns the dictionary representation of the file.
:param str template: Path to the template file
:return dict: Dictionary representing the SAM Template
:raises: SamTemplateNotFoundException when the template file does not exist
"""
from samcli.commands.local.cli_common.user_exceptions import SamTemplateNotFoundException
from samcli.yamlhelper import yaml_parse
if not os.path.exists(template):
click.secho("SAM Template Not Found", bg="red")
raise SamTemplateNotFoundException("Template at {} is not found".format(template))
with click.open_file(template, "r", encoding="utf-8") as sam_template:
sam_template = yaml_parse(sam_template.read())
return sam_template
def get_template_data(template_file):
"""
Read the template file, parse it as JSON/YAML and return the template as a dictionary.
Parameters
----------
template_file : string
Path to the template to read
Returns
-------
Template data as a dictionary
"""
if not pathlib.Path(template_file).exists():
raise TemplateNotFoundException("Template file not found at {}".format(template_file))
with open(template_file, "r", encoding="utf-8") as fp:
try:
return yaml_parse(fp.read())
except (ValueError, yaml.YAMLError) as ex:
raise TemplateFailedParsingException("Failed to parse template: {}".format(str(ex))) from ex
def get_template_data(template_file):
"""
Read the template file, parse it as JSON/YAML and return the template as a dictionary.
Parameters
----------
template_file : string
Path to the template to read
Returns
-------
Template data as a dictionary
"""
if not pathlib.Path(template_file).exists():
raise ValueError("Template file not found at {}".format(template_file))
with open(template_file, 'r') as fp:
try:
return yaml_parse(fp.read())
except (ValueError, yaml.YAMLError) as ex:
raise ValueError("Failed to parse template: {}".format(str(ex)))
def test_parse_json_preserve_elements_order(self):
input_template = """
{
"B_Resource": {
"Key2": {
"Name": "name2"
},
"Key1": {
"Name": "name1"
}
},
"A_Resource": {
"Key2": {
"Name": "name2"
},
"Key1": {
"Name": "name1"
}
}
}
"""
expected_dict = OrderedDict([
("B_Resource",
OrderedDict([("Key2", {
"Name": "name2"
}), ("Key1", {
"Name": "name1"
})])),
("A_Resource",
OrderedDict([("Key2", {
"Name": "name2"
}), ("Key1", {
"Name": "name1"
})])),
])
output_dict = yaml_parse(input_template)
self.assertEqual(expected_dict, output_dict)
def test_code_deploy_warning(self, template, expected):
code_deploy_warning = CodeDeployWarning()
(is_warning, message) = code_deploy_warning.check(yaml_parse(template))
self.assertEqual(expected, is_warning)
def test_parse_json_with_tabs(self):
template = '{\n\t"foo": "bar"\n}'
output = yaml_parse(template)
self.assertEqual(output, {'foo': 'bar'})
def test_warning_check_invalid_warning_name(self):
template_dict = yaml_parse(ALL_ENABLED_TEMPLATE)
current_warning_checker = TemplateWarningsChecker()
actual_warning_msg = current_warning_checker.check_template_for_warning("SomeRandomName", template_dict)
self.assertIsNone(actual_warning_msg)
def test_parse_json_with_tabs(self):
template = '{\n\t"foo": "bar"\n}'
output = yaml_parse(template)
self.assertEqual(output, {'foo': 'bar'})
def _verify_resource_property(self, template_path, logical_id, property, expected_value):
with open(template_path, 'r') as fp:
template_dict = yaml_parse(fp.read())
self.assertEquals(expected_value, template_dict["Resources"][logical_id]["Properties"][property])
