def test_resolve_parameter_values_returns_list_with_string_value(self):
stack_config = Mock()
stack_config.parameters = {'foo': "baa"}
result = ParameterResolver().resolve_parameter_values(
'foo', stack_config)
self.assertEqual({'foo': 'baa'}, result)
def test_resolve_parameter_values_returns_str_representation_of_float(
self):
stack_config = Mock()
stack_config.parameters = {'foo': 5.555}
result = ParameterResolver().resolve_parameter_values(
'foo', stack_config)
self.assertEqual({'foo': '5.555'}, result)
def test_resolve_parameter_values_raises_exception_on_none_value(self):
stack_config = Mock()
stack_config.parameters = {'foo': None}
with self.assertRaises(CfnSphereException):
ParameterResolver(self.cfn_mock).resolve_parameter_values(
'foo', stack_config)
def __init__(self, config, dry_run=False):
self.logger = get_logger(root=True)
self.config = config
self.cfn = CloudFormation(region=self.config.region, dry_run=dry_run)
self.parameter_resolver = ParameterResolver(self.cfn,
region=self.config.region)
self.cli_parameters = config.cli_params
def test_handle_kms_value_ignores_encryption_context_if_not_set(self):
self.kms_mock.return_value.decrypt.return_value = "decryptedValue"
result = ParameterResolver().handle_kms_value('|kms|encryptedValue')
self.kms_mock.return_value.decrypt.assert_called_once_with(
'encryptedValue')
self.assertEqual(result, 'decryptedValue')
def test_resolve_parameter_values_calls_convert_list_to_string_on_list_value(
self, convert_list_to_string_mock):
stack_config = Mock()
stack_config.parameters = {'foo': ['a', 'b']}
ParameterResolver().resolve_parameter_values('foo', stack_config)
convert_list_to_string_mock.assert_called_once_with(['a', 'b'])
def test_get_latest_value_raises_exception_on_error(self):
self.cfn_mock.get_stack_parameters_dict = MagicMock(
side_effect=Exception("foo"))
resolver = ParameterResolver(self.cfn_mock)
with self.assertRaises(CfnSphereException):
resolver.get_latest_value('my-key', '|keepOrUse|default-value',
'my-stack')
def test_resolve_parameter_values_returns_str_representation_of_false(
self):
stack_config = Mock()
stack_config.parameters = {'foo': False}
result = ParameterResolver(self.cfn_mock).resolve_parameter_values(
'foo', stack_config)
self.assertEqual({'foo': 'false'}, result)
def test_get_latest_value_returns_stacks_actual_value(self, kms, ec2_api, cfn_mock):
cfn_mock.return_value.get_stack_parameters_dict.return_value = {'my-key': 'my-actual-value'}
pr = ParameterResolver()
result = pr.get_latest_value('my-key', '|keepOrUse|default-value', 'my-stack')
cfn_mock.return_value.get_stack_parameters_dict.assert_called_once_with('my-stack')
self.assertEqual('my-actual-value', result)
def test_resolve_parameter_values_returns_decrypted_value(self):
self.kms_mock.return_value.decrypt.return_value = "decryptedValue"
stack_config = Mock()
stack_config.parameters = {'foo': '|kms|encryptedValue'}
result = ParameterResolver().resolve_parameter_values('foo', stack_config)
self.assertEqual(result, {'foo': 'decryptedValue'})
def test_resolve_value_from_file(self, get_file_mock):
get_file_mock.return_value = "line1\nline2"
stack_config = Mock()
stack_config.parameters = {'foo': "|file|abc.txt"}
result = ParameterResolver().resolve_parameter_values('foo', stack_config)
self.assertEqual({'foo': 'line1\nline2'}, result)
def test_get_latest_value_returns_default_value_called_once_with_stack(self):
self.cfn_mock.return_value.get_stack_parameters_dict.return_value = {'not-my-key': 'my-actual-value'}
pr = ParameterResolver()
result = pr.get_latest_value('my-key', '|keepOrUse|default-value', 'my-stack')
self.cfn_mock.return_value.get_stack_parameters_dict.assert_called_once_with('my-stack')
self.assertEqual('default-value', result)
def test_update_parameters_with_cli_parameters_does_not_affect_other_stacks(
self):
result = ParameterResolver().update_parameters_with_cli_parameters(
parameters={'foo': "foo"},
cli_parameters={'stack1': {
'foo': 'foobar'
}},
stack_name='stack2')
self.assertEqual({'foo': 'foo'}, result)
def test_update_parameters_with_cli_parameters_with_string_param_value(
self):
result = ParameterResolver().update_parameters_with_cli_parameters(
parameters={'foo': "foo"},
cli_parameters={'stack1': {
'foo': 'foobar'
}},
stack_name='stack1')
self.assertEqual({'foo': 'foobar'}, result)
def test_update_parameters_with_cli_parameters_adds_new_cli_parameter(
self):
result = ParameterResolver().update_parameters_with_cli_parameters(
parameters={'foo': 'foo'},
cli_parameters={'stack1': {
'moppel': 'foo'
}},
stack_name='stack1')
self.assertDictEqual({'foo': 'foo', 'moppel': 'foo'}, result)
def test_resolve_parameters_with_cli_parameters_(self):
cli_parameters = {'stack1': {'foo': 'foobar'}, 'stack2': {'foo': 'foofoo'}}
stack_config = Mock()
stack_config.parameters = {'foo': "bar"}
result = ParameterResolver().resolve_parameter_values("stack1", stack_config, cli_parameters)
self.assertEqual({'foo': 'foobar'}, result)
def test_resolve_parameter_values_returns_ssm_value(self):
self.ssm_mock.return_value.get_parameter.return_value = "decryptedValue"
stack_config = Mock()
stack_config.parameters = {'foo': '|ssm|/path/to/my/key'}
result = ParameterResolver().resolve_parameter_values(
'foo', stack_config)
self.assertEqual(result, {'foo': 'decryptedValue'})
def test_resolve_parameter_values_returns_ref_list_value(self, cfn_mock, get_output_value_mock):
cfn_mock.return_value.get_stacks_outputs.return_value = None
get_output_value_mock.return_value = 'bar'
stack_config = Mock()
stack_config.parameters = {'foo': ['|Ref|stack.output', '|Ref|stack.output']}
result = ParameterResolver().resolve_parameter_values('foo', stack_config)
get_output_value_mock.assert_called_with(None, "stack", "output")
self.assertEqual({'foo': 'bar,bar'}, result)
def test_get_latest_value_returns_stacks_actual_value(self):
self.cfn_mock.get_stack_parameters_dict = MagicMock(
return_value={'my-key': 'my-actual-value'})
pr = ParameterResolver(self.cfn_mock)
result = pr.get_latest_value('my-key', '|keepOrUse|default-value',
'my-stack')
self.cfn_mock.get_stack_parameters_dict.assert_called_once_with(
'my-stack')
self.assertEqual('my-actual-value', result)
def test_resolve_parameter_values_returns_ref_value(
self, get_output_value_mock):
self.cfn_mock.get_stacks_outputs = MagicMock(return_value=None)
get_output_value_mock.return_value = 'bar'
stack_config = Mock()
stack_config.parameters = {'foo': '|Ref|stack.output'}
result = ParameterResolver(self.cfn_mock).resolve_parameter_values(
'foo', stack_config)
get_output_value_mock.assert_called_with(None, "stack", "output")
self.assertEqual({'foo': 'bar'}, result)
def test_update_parameters_with_cli_parameters_with_string_param_value_for_several_stacks(
self):
result = ParameterResolver(
self.cfn_mock).update_parameters_with_cli_parameters(
parameters={'foo': "foo"},
cli_parameters={
'stack1': {
'foo': 'foobar'
},
'stack2': {
'foo': 'foofoo'
}
},
stack_name='stack2')
self.assertEqual({'foo': 'foofoo'}, result)
def test_resolve_parameter_values_returns_str_representation_of_float(self, kms, ec2_api, cfn):
result = ParameterResolver().resolve_parameter_values({'foo': 5.555}, 'foo')
self.assertEqual({'foo': '5.555'}, result)
def test_handle_kms_value_raises_exception_on_invalid_value_format(self):
with self.assertRaises(CfnSphereException):
ParameterResolver().handle_kms_value(
'|kms|k=v|encryptedValue|something')
def test_get_latest_value_returns_default_value(self, kms, ec2_api, cfn_mock):
cfn_mock.return_value.get_stack_parameters_dict.side_effect = CfnSphereBotoError(BotoServerError("500", "foo"))
resolver = ParameterResolver()
with self.assertRaises(CfnSphereException):
resolver.get_latest_value('my-key', '|keepOrUse|default-value', 'my-stack')
def test_handle_ssm_value_raises_exception_on_invalid_value_format(self):
with self.assertRaises(CfnSphereException):
ParameterResolver().handle_ssm_value('|ssm|/test/|invalid')
def test_resolve_parameter_values_returns_list_with_string_value(self, kms, ec2_api, cfn):
result = ParameterResolver().resolve_parameter_values({'foo': "baa"}, 'foo')
self.assertEqual({'foo': 'baa'}, result)
def test_resolve_parameter_values_calls_convert_list_to_string_on_list_value(self, kms, ec2_api, cfn, convert_list_to_string_mock):
ParameterResolver().resolve_parameter_values({'foo': ['a', 'b']}, 'foo')
convert_list_to_string_mock.assert_called_once_with(['a', 'b'])
def test_resolve_parameter_values_raises_exception_on_none_value(self, kms, ec2_api, cfn):
with self.assertRaises(NotImplementedError):
ParameterResolver().resolve_parameter_values({'foo': None}, 'foo')
def test_resolve_parameter_values_raises_exception_on_none_value(self):
stack_config = Mock()
stack_config.parameters = {'foo': None}
with self.assertRaises(NotImplementedError):
ParameterResolver().resolve_parameter_values('foo', stack_config)
def test_resolve_parameter_values_returns_decrypted_value(self, kms_mock, ec2_api, cfn):
kms_mock.return_value.decrypt.return_value = "decryptedValue"
result = ParameterResolver().resolve_parameter_values({'foo': "|kms|encryptedValue"}, 'foo')
self.assertEqual({'foo': 'decryptedValue'}, result)
