def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
context.output = stack.template.body
except Exception as e:
context.error = e
def get_stack_or_stack_group(ctx, path):
"""
Parses the path to generate relevant Stack Group and Stack object.
:param ctx: Cli context.
:type ctx: click.Context
:param path: Path to either stack config or stack_group folder.
:type path: str
"""
stack = None
stack_group = None
config_reader = ConfigReader(ctx.obj["sceptre_dir"],
ctx.obj["user_variables"])
if os.path.splitext(path)[1]:
stack = config_reader.construct_stack(path)
else:
# <<<<<<< HEAD
#
# env = config_reader.construct_environment(path)
# =======
# stack_group = config_reader.construct_stack_group(path)
# >>>>>>> cfb45a0c7c9e4567f765d4ee4c7dbfe05ebfa0b9
stack_group = config_reader.construct_stack_group(path)
return (stack, stack_group)
def test_read_with_empty_config_file(self):
config_reader = ConfigReader(self.test_sceptre_directory)
config = config_reader.read("account/stack-group/region/subnets.yaml")
assert config == {
"sceptre_dir": self.test_sceptre_directory,
"stack_group_path": "account/stack-group/region"
}
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
stack.launch()
except Exception as e:
context.error = e
def test_read_with_templated_config_file(self):
config_reader = ConfigReader(
self.test_sceptre_directory,
{"user_variable": "user_variable_value"}
)
config_reader.templating_vars["environment_config"] = {
"region": "environment_region"
}
os.environ["TEST_ENV_VAR"] = "environment_variable_value"
config = config_reader.read(
"account/environment/region/security_groups.yaml"
)
# self.config.read({"user_variable": "user_variable_value"})
assert config == {
'sceptre_dir': config_reader.sceptre_dir,
"environment_path": "account/environment/region",
"parameters": {
"param1": "user_variable_value",
"param2": "environment_variable_value",
"param3": "account",
"param4": "environment",
"param5": "region",
"param6": "environment_region"
}
}
def test_construct_stack_with_valid_config(
self, mock_Stack, mock_collect_s3_details
):
mock_Stack.return_value = sentinel.stack
mock_collect_s3_details.return_value = sentinel.s3_details
config_reader = ConfigReader(self.test_sceptre_directory)
stack = config_reader.construct_stack(
"account/environment/region/vpc.yaml"
)
mock_Stack.assert_called_with(
name="account/environment/region/vpc",
project_code="account_project_code",
template_path=os.path.join(
self.test_sceptre_directory, "path/to/template"
),
region="region_region",
iam_role="account_iam_role",
parameters={"param1": "val1"},
sceptre_user_data={},
hooks={},
s3_details=sentinel.s3_details,
dependencies=[],
role_arn=None,
protected=False,
tags={},
external_name=None,
notifications=None,
on_failure=None,
stack_timeout=0
)
assert stack == sentinel.stack
def test_read_with_empty_config_file(self):
config_reader = ConfigReader(self.test_sceptre_directory)
config = config_reader.read("account/environment/region/subnets.yaml")
assert config == {
"sceptre_dir": self.test_sceptre_directory,
"environment_path": "account/environment/region"
}
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
stack.lock()
except ClientError as e:
context.error = e
def test_construct_nodes(self):
def add(value):
return 1 + value
attr = {
"parameters": {
"param1": partial(add),
"param2": {
"param3": partial(add),
"param4": partial(add)
},
"param5": [partial(add), partial(add)]
},
"sceptre_user_data": [partial(add), [partial(add),
partial(add)]]
}
ConfigReader._construct_nodes(attr, 1)
assert attr == {
"parameters": {
"param1": 2,
"param2": {
"param3": 2,
"param4": 2
},
"param5": [2, 2]
},
"sceptre_user_data": [2, [2, 2]]
}
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
context.response = stack.template.validate()
except ClientError as e:
context.error = e
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
stack.delete()
except ClientError as e:
if e.response['Error']['Code'] == 'ValidationError' \
and e.response['Error']['Message'].endswith("does not exist"):
return
else:
raise e
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
stack.create()
except ClientError as e:
if e.response['Error']['Code'] == 'AlreadyExistsException' \
and e.response['Error']['Message'].endswith("already exists"):
return
else:
raise e
def step_impl(context, change_set_name, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
allowed_errors = {'ValidationError', 'ChangeSetNotFound'}
try:
stack.execute_change_set(change_set_name)
except ClientError as e:
if e.response['Error']['Code'] in allowed_errors:
context.error = e
return
else:
raise e
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
try:
stack.update()
except ClientError as e:
message = e.response['Error']['Message']
if e.response['Error']['Code'] == 'ValidationError' \
and (message.endswith("does not exist")
or message.endswith("No updates are to be performed.")):
return
else:
raise e
def test_read_reads_config_file_with_base_config(self):
with self.runner.isolated_filesystem():
sceptre_dir = os.path.abspath('./example')
config_dir = os.path.join(sceptre_dir, "config")
env_dir = os.path.join(config_dir, "A")
os.makedirs(env_dir)
config = {"config": "config"}
with open(os.path.join(env_dir, "stack.yaml"), 'w') as config_file:
yaml.safe_dump(
config, stream=config_file, default_flow_style=False
)
base_config = {
"base_config": "base_config"
}
config = ConfigReader(sceptre_dir).read(
"A/stack.yaml", base_config
)
assert config == {
"sceptre_dir": sceptre_dir,
"environment_path": "A",
"config": "config",
"base_config": "base_config"
}
def test_read_reads_config_file(self, filepaths, target):
with self.runner.isolated_filesystem():
sceptre_dir = os.path.abspath('./example')
config_dir = os.path.join(sceptre_dir, "config")
os.makedirs(config_dir)
for rel_path in filepaths:
abs_path = os.path.join(config_dir, rel_path)
if not os.path.exists(os.path.dirname(abs_path)):
try:
os.makedirs(os.path.dirname(abs_path))
except OSError as exc:
if exc.errno != errno.EEXIST:
raise
config = {"filepath": rel_path}
with open(abs_path, 'w') as config_file:
yaml.safe_dump(
config, stream=config_file, default_flow_style=False
)
config = ConfigReader(sceptre_dir).read(target)
assert config == {
"sceptre_dir": sceptre_dir,
"environment_path": os.path.split(target)[0],
"filepath": target
}
def test_read_with_nonexistant_filepath(self):
with self.runner.isolated_filesystem():
sceptre_dir = os.path.abspath('./example')
config_dir = os.path.join(sceptre_dir, "config")
os.makedirs(config_dir)
with pytest.raises(ConfigFileNotFoundError):
ConfigReader(sceptre_dir).read("stack.yaml")
def test_construct_environment_with_valid_config(
self, filepaths, targets, results
):
with self.runner.isolated_filesystem():
sceptre_dir = os.path.abspath('./example')
config_dir = os.path.join(sceptre_dir, "config")
os.makedirs(config_dir)
for rel_path in filepaths:
abs_path = os.path.join(config_dir, rel_path)
dir_path = abs_path
if abs_path.endswith(".yaml"):
dir_path = os.path.split(abs_path)[0]
if not os.path.exists(dir_path):
try:
os.makedirs(dir_path)
except OSError as exc:
if exc.errno != errno.EEXIST:
raise
config = {
"region": "region",
"project_code": "project_code",
"template_path": rel_path
}
with open(abs_path, 'w') as config_file:
yaml.safe_dump(
config, stream=config_file, default_flow_style=False
)
config_reader = ConfigReader(sceptre_dir)
def check_environment(environment, details):
assert sorted(details["stacks"]) == sorted([
stack.name for stack in environment.stacks
])
for sub_env in environment.sub_environments:
sub_env_details = details["environments"][sub_env.path]
check_environment(sub_env, sub_env_details)
for i, target in enumerate(targets):
environment = config_reader.construct_environment(target)
expected = results[i]
check_environment(environment, expected[environment.path])
def get_stack(ctx, path):
"""
Parses the path to generate relevant StackGroup and Stack object.
:param ctx: Cli context.
:type ctx: click.Context
:param path: Path to either stack config or stack_group folder.
:type path: str
"""
return ConfigReader(ctx.obj["sceptre_dir"],
ctx.obj["options"]).construct_stack(path)
def get_stack_or_env(ctx, path):
"""
Parses the path to generate relevant Envrionment and Stack object.
:param ctx: Cli context.
:type ctx: click.Context
:param path: Path to either stack config or environment folder.
:type path: str
"""
stack = None
env = None
config_reader = ConfigReader(ctx.obj["sceptre_dir"], ctx.obj["options"])
if os.path.splitext(path)[1]:
stack = config_reader.construct_stack(path)
else:
env = config_reader.construct_environment(path)
return (stack, env)
def get_stack_or_stack_group(ctx, path):
"""
Parses the path to generate relevant Stack Group and Stack object.
:param ctx: Cli context.
:type ctx: click.Context
:param path: Path to either stack config or stack_group folder.
:type path: str
"""
stack = None
stack_group = None
config_reader = ConfigReader(ctx.obj["sceptre_dir"],
ctx.obj["user_variables"])
if os.path.splitext(path)[1]:
stack = config_reader.construct_stack(path)
else:
stack_group = config_reader.construct_stack_group(path)
return (stack, stack_group)
def step_impl(context, environment_name):
env = ConfigReader(context.sceptre_dir).construct_environment(environment_name)
context.response = env.describe_resources()
def step_impl(context, environment_name):
env = ConfigReader(context.sceptre_dir).construct_environment(environment_name)
env.delete()
def step_impl(context, stack_group_name):
stack_group = ConfigReader(context.sceptre_dir).construct_stack_group(stack_group_name)
context.response = stack_group.describe_resources()
def step_impl(context, stack_group_name):
stack_group = ConfigReader(context.sceptre_dir).construct_stack_group(stack_group_name)
stack_group.delete()
def test_aborts_on_incompatible_version_requirement(self):
config = {
'require_version': '<0'
}
with pytest.raises(VersionIncompatibleError):
ConfigReader(self.test_sceptre_directory)._check_version(config)
def test_collect_s3_details(self, stack_name, config, expected):
details = ConfigReader._collect_s3_details(stack_name, config)
assert details == expected
def step_impl(context, stack_name):
config_reader = ConfigReader(context.sceptre_dir)
stack = config_reader.construct_stack(stack_name + ".yaml")
context.output = stack.describe_resources()
def test_config_reader_correctly_initialised(self):
config_reader = ConfigReader(self.test_sceptre_directory)
assert config_reader.sceptre_dir == self.test_sceptre_directory
def test_config_reader_with_invalid_path(self):
with pytest.raises(InvalidSceptreDirectoryError):
ConfigReader("/path/does/not/exist")