def test_add_two_valid_files(self):
with TempDirectory() as temp_dir:
config_dir = "test"
config_files = [
{
'name': os.path.join(config_dir,'foo.yml'),
'contents' : {
Config.CONFIG_KEY: {
'step-test-foo' : {
'implementer': 'foo',
'config': {
'f': 'hello1'
}
}
}
}
},
{
'name': os.path.join(config_dir,'bar.yml'),
'contents' : {
Config.CONFIG_KEY: {
'step-test-bar' : {
'implementer': 'bar',
'config': {
'b': 'hello2'
}
}
}
}
},
]
for config_file in config_files:
config_file_name = config_file['name']
config_file_contents = config_file['contents']
temp_dir.write(
config_file_name,
bytes(f"{config_file_contents}", 'utf-8')
)
config = Config()
config.add_config(
[
os.path.join(temp_dir.path, config_dir, 'foo.yml'),
os.path.join(temp_dir.path, config_dir, 'bar.yml')
]
)
self.assertEqual(config.global_defaults, {})
self.assertEqual(config.global_environment_defaults, {})
self.assertEqual(
config.get_step_config('step-test-foo').get_sub_step('foo').get_config_value('f'),
'hello1'
)
self.assertEqual(
config.get_step_config('step-test-bar').get_sub_step('bar').get_config_value('b'),
'hello2'
)
def test_set_step_config_overrides_not_existing_step(self):
config = Config({Config.CONFIG_KEY: {}})
self.assertIsNone(config.get_step_config('step-bar'))
config.set_step_config_overrides('step-bar', {'test1': 'test2'})
step_config = config.get_step_config('step-bar')
self.assertIsNotNone(step_config)
self.assertEqual(step_config.step_config_overrides, {'test1': 'test2'})
def test_fail(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FailStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FailStepImplementer')
with TempDirectory() as test_dir:
results_dir_path = os.path.join(test_dir.path,
'step-runner-results')
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FailStepImplementer(
results_dir_path=results_dir_path,
results_file_name='step-runner-results.yml',
work_dir_path=working_dir_path,
config=sub_step)
result = step.run_step()
self.assertEqual(False, result)
def test_get_sub_step_env_config(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [
{
'implementer': 'foo1',
'config': {
'test1': 'foo'
},
'environment-config': {
'env1': {
'test2': 'bar'
}
}
}
]
}
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
self.assertEqual(
ConfigValue.convert_leaves_to_values(
sub_step.get_sub_step_env_config('env1')
),
{
'test2': 'bar'
}
)
def test_add_or_update_sub_step_config_exising_sub_step(self):
config = Config([
{
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}]
}
},
{
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'config': {
'test2': 'foo'
}
}]
}
},
])
step_config = config.get_step_config('step-foo')
self.assertEqual(len(step_config.sub_steps), 1)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('foo1').sub_step_config), {
'test1': 'foo',
'test2': 'foo'
})
def test_sub_step_with_no_environment_config(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [
{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}
]
}
})
step_config = config.get_step_config('step-foo')
self.assertEqual(len(step_config.sub_steps), 1)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('foo1').sub_step_config
),
{
'test1': 'foo'
}
)
self.assertEqual(step_config.get_sub_step('foo1').get_sub_step_env_config('env1'), {})
def test_write_working_file_touch(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
with TempDirectory() as test_dir:
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FooStepImplementer(workflow_result=WorkflowResult(),
parent_work_dir_path=working_dir_path,
config=sub_step)
step.write_working_file('foo/test.json')
working_file_path = os.path.join(working_dir_path,
'foo/foo/test.json')
self.assertTrue(os.path.exists(working_file_path))
with open(working_file_path, 'r') as working_file:
self.assertEqual(working_file.read(), '')
def test_global_defaults(self):
config = Config({
Config.CONFIG_KEY: {
'global-defaults': {
'test1': 'global-default-1',
'test2': 'global-default-2'
},
'step-foo': [{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}]
}
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
self.assertEqual(
sub_step.global_defaults, {
'test1':
ConfigValue(
'global-default-1', None,
["step-runner-config", "global-defaults", "test1"]),
'test2':
ConfigValue('global-default-2', None,
["step-runner-config", "global-defaults", "test2"])
})
def test_get_config_value_list(self):
config = Config({
Config.CONFIG_KEY: {
'global-defaults': {
'global-default-unique-0':
['global-default-a', 'global-default-b'],
},
'step-foo': [{
'implementer': 'foo1',
'config': {
'step-foo-foo1-unique-0':
['step-foo-foo1-a', 'step-foo-foo1-b'],
}
}]
}
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
self.assertEqual(sub_step.get_config_value('global-default-unique-0'),
['global-default-a', 'global-default-b'])
self.assertEqual(sub_step.get_config_value('step-foo-foo1-unique-0'),
['step-foo-foo1-a', 'step-foo-foo1-b'])
def test_create_working_dir_sub_dir(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
with TempDirectory() as test_dir:
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FooStepImplementer(workflow_result=WorkflowResult(),
parent_work_dir_path=working_dir_path,
config=sub_step)
sub = step.create_working_dir_sub_dir('folder1')
self.assertEqual(sub, f'{working_dir_path}/foo/folder1')
self.assertEqual(True, os.path.isdir(sub))
sub = step.create_working_dir_sub_dir('folder1/folder2/folder3')
self.assertEqual(
sub, f'{working_dir_path}/foo/folder1/folder2/folder3')
self.assertEqual(True, os.path.isdir(sub))
def test_sub_step_with_name(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [
{
'name': 'sub-step-name-test',
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}
]
}
})
step_config = config.get_step_config('step-foo')
self.assertEqual(len(step_config.sub_steps), 1)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('sub-step-name-test').sub_step_config
),
{
'test1': 'foo'
}
)
def create_given_step_implementer_rekor_sign_generic(
self,
step_implementer,
step_config={},
step_name='',
environment=None,
implementer='',
workflow_result=None,
parent_work_dir_path='',
artifact_to_sign_uri_config_key=None):
config = Config({
Config.CONFIG_KEY: {
step_name: [{
'implementer': implementer,
'config': step_config
}]
}
})
step_config = config.get_step_config(step_name)
sub_step_config = step_config.get_sub_step(implementer)
if not workflow_result:
workflow_result = WorkflowResult()
step_implementer = step_implementer(
workflow_result=workflow_result,
parent_work_dir_path=parent_work_dir_path,
config=sub_step_config,
artifact_to_sign_uri_config_key=artifact_to_sign_uri_config_key,
environment=environment)
return step_implementer
def test_multiple_sub_steps(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}, {
'implementer': 'foo2',
'config': {
'test2': 'foo'
}
}]
}
})
step_config = config.get_step_config('step-foo')
self.assertEqual(len(step_config.sub_steps), 2)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('foo1').sub_step_config, ),
{'test1': 'foo'})
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('foo2').sub_step_config),
{'test2': 'foo'})
def test_sub_step_with_continue_sub_steps_on_failure_str(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'continue-sub-steps-on-failure': 'true',
'config': {
'test1': 'foo'
}
}, {
'implementer': 'foo2',
'config': {
'test2': 'foo'
}
}]
}
})
step_config = config.get_step_config('step-foo')
self.assertEqual(len(step_config.sub_steps), 2)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('foo1').sub_step_config, ),
{'test1': 'foo'})
self.assertEqual(
ConfigValue.convert_leaves_to_values(
step_config.get_sub_step('foo2').sub_step_config),
{'test2': 'foo'})
self.assertTrue(
step_config.get_sub_step(
'foo1').sub_step_contine_sub_steps_on_failure)
self.assertFalse(
step_config.get_sub_step(
'foo2').sub_step_contine_sub_steps_on_failure)
def test_from_step_implementer_with_env(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
step = FooStepImplementer(workflow_result=WorkflowResult(),
parent_work_dir_path=None,
config=sub_step,
environment='blarg')
step_result = StepResult.from_step_implementer(step)
expected_step_result = StepResult(
step_name='foo',
sub_step_name=
'tests.helpers.sample_step_implementers.FooStepImplementer',
sub_step_implementer_name=
'tests.helpers.sample_step_implementers.FooStepImplementer',
environment='blarg')
self.assertEqual(step_result, expected_step_result)
def test_write_working_file(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
with TempDirectory() as test_dir:
results_dir_path = os.path.join(test_dir.path,
'step-runner-results')
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FooStepImplementer(
results_dir_path=results_dir_path,
results_file_name='step-runner-results.yml',
work_dir_path=working_dir_path,
config=sub_step)
step.write_working_file('test-working-file', b'hello world')
with open(os.path.join(working_dir_path, 'foo', 'test-working-file'), 'r') \
as working_file:
self.assertEqual(working_file.read(), 'hello world')
def test_has_config_value(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {
'test': 'hello world',
'env-config-override-key': 'override-me',
'username': '******',
'password': '******'
},
'environment-config': {
'SAMPLE-ENV-1': {
'env-config-override-key':
'step env config - env 1 value - 1'
},
'SAMPLE-ENV-2': {
'env-config-override-key':
'step env config - env 2 value - 1'
}
},
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
with TempDirectory() as test_dir:
results_dir_path = os.path.join(test_dir.path,
'step-runner-results')
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FooStepImplementer(
results_dir_path=results_dir_path,
results_file_name='step-runner-results.yml',
work_dir_path=working_dir_path,
config=sub_step,
environment='SAMPLE-ENV-1')
self.assertFalse(step.has_config_value('bar'))
self.assertFalse(step.has_config_value(['bar']))
self.assertFalse(step.has_config_value(['username', 'foo'], False))
self.assertTrue(step.has_config_value(['username', 'foo'], True))
self.assertTrue(
step.has_config_value(['username', 'password'], False))
self.assertTrue(
step.has_config_value(['username', 'password'], True))
def test_step_name(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}]
}
})
step_config = config.get_step_config('step-foo')
self.assertEqual(step_config.step_name, 'step-foo')
def test_get_sub_step_non_existing_sub_step_name(self):
config = Config([{
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}]
}
}])
step_config = config.get_step_config('step-foo')
self.assertIsNone(step_config.get_sub_step('does-not-exist'))
def test_global_environment_defaults(self):
config = Config({
Config.CONFIG_KEY: {
'global-environment-defaults': {
'env1': {
'test1': 'global-env1-default-1',
'test2': 'global-env1-default-2'
},
'env2': {
'test1': 'global-env2-default-1',
'test2': 'global-env2-default-2'
}
},
'step-foo': [
{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}
]
}
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
self.assertEqual(
ConfigValue.convert_leaves_to_values(
sub_step.get_global_environment_defaults('env1')
),
{
'environment-name': 'env1',
'test1': 'global-env1-default-1',
'test2': 'global-env1-default-2'
}
)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
sub_step.get_global_environment_defaults('env2')
),
{
'environment-name': 'env2',
'test1': 'global-env2-default-1',
'test2': 'global-env2-default-2'
}
)
def test_parent_config(self):
config = Config({
Config.CONFIG_KEY: {
'step-foo': [{
'implementer': 'foo1',
'config': {
'test1': 'foo'
}
}]
}
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
self.assertEqual(sub_step.parent_config, config)
def test_get_config_value_with_env(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {
'test': 'hello world',
'env-config-override-key': 'override-me'
},
'environment-config': {
'SAMPLE-ENV-1': {
'env-config-override-key':
'step env config - env 1 value - 1'
},
'SAMPLE-ENV-2': {
'env-config-override-key':
'step env config - env 2 value - 1'
}
},
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
with TempDirectory() as test_dir:
results_dir_path = os.path.join(test_dir.path,
'step-runner-results')
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FooStepImplementer(
results_dir_path=results_dir_path,
results_file_name='step-runner-results.yml',
work_dir_path=working_dir_path,
config=sub_step,
environment='SAMPLE-ENV-1')
self.assertEqual(step.get_config_value('test'), 'hello world')
self.assertIsNone(step.get_config_value('does-not-exist'))
self.assertEqual(step.get_config_value('env-config-override-key'),
'step env config - env 1 value - 1')
def test_fail(self):
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FailStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FailStepImplementer')
with TempDirectory() as test_dir:
working_dir_path = os.path.join(test_dir.path,
'step-runner-working')
step = FailStepImplementer(workflow_result=WorkflowResult(),
parent_work_dir_path=working_dir_path,
config=sub_step)
result = step.run_step()
self.assertEqual(False, result.success)
def test_empty_constructor_params(self):
config = Config({
'step-runner-config': {
'write-config-as-results': {
'implementer':
'tests.helpers.sample_step_implementers.'
'WriteConfigAsResultsStepImplementer'
}
}
})
step_config = config.get_step_config('write-config-as-results')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.'
'WriteConfigAsResultsStepImplementer')
step = WriteConfigAsResultsStepImplementer(workflow_result=None,
parent_work_dir_path='',
config=sub_step)
self.assertEqual(step.step_environment_config, {})
self.assertEqual(step.step_config, {})
self.assertEqual(step.global_config_defaults, {})
self.assertEqual(step.global_environment_config_defaults, {})
def test_result_files_and_paths(self):
# overkill on tests here
config = Config({
'step-runner-config': {
'foo': {
'implementer':
'tests.helpers.sample_step_implementers.FooStepImplementer',
'config': {}
}
}
})
step_config = config.get_step_config('foo')
sub_step = step_config.get_sub_step(
'tests.helpers.sample_step_implementers.FooStepImplementer')
with TempDirectory() as test_dir:
results_dir_path = os.path.join(test_dir.path, 'myresults')
working_dir_path = os.path.join(test_dir.path, 'mytesting')
step = FooStepImplementer(results_dir_path=results_dir_path,
results_file_name='myfile',
work_dir_path=working_dir_path,
config=sub_step)
self.assertEqual(f'{results_dir_path}/myfile',
step.results_file_path)
self.assertEqual(f'{results_dir_path}', step.results_dir_path)
self.assertEqual(f'{working_dir_path}', step.work_dir_path)
self.assertEqual(f'{working_dir_path}/foo',
step.work_dir_path_step)
self.assertEqual(
f'{working_dir_path}/myfile.pkl',
step._StepImplementer__workflow_result_pickle_file_path)
def test_get_copy_of_runtime_step_config_default_global_defaults_global_env_defaults_sub_step_config_sub_step_env_config_step_config_overrides(
self):
config = Config({
Config.CONFIG_KEY: {
'global-defaults': {
'global-default-unique-0': 'global-default',
'global-default-override-by-global-env-default-0':
'global-default-override-me',
'global-default-override-by-step-config-0':
'global-default-override-me',
'global-default-override-by-step-env-config-0':
'global-default-override-me',
'global-default-override-by-step-config-override-0':
'global-default-override-me',
'default-overriden-by-global-default': 'global-default',
},
'global-environment-defaults': {
'env1': {
'global-default-override-by-global-env-default-0':
'global-environment-defaults-1',
'global-env-default-env1-unique-0':
'global-environment-defaults-1',
'global-env-default-override-by-step-config':
'global-environment-defaults-1',
'default-overriden-by-global-env-default':
'global-environment-defaults-1'
},
'env2': {
'global-default-override-by-global-env-default-0':
'global-environment-defaults-2',
'global-env-default-env2-unique-0':
'global-environment-defaults-2',
'global-env-default-override-by-step-config':
'global-environment-defaults-2',
'default-overriden-by-global-env-default':
'global-environment-defaults-2'
}
},
'step-foo': [{
'implementer': 'foo1',
'config': {
'step-foo-foo1-unique-0': 'step-foo-foo1',
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-override-me',
'step-foo-foo1-override-by-step-override':
'step-foo-foo-override-me',
'global-default-override-by-step-config-0':
'step-foo-foo1',
'global-env-default-override-by-step-config':
'step-foo-foo1',
'default-overriden-by-step-config': 'step-foo-foo1'
},
'environment-config': {
'env1': {
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-env1',
'global-default-override-by-step-env-config-0':
'step-foo-foo-env1',
'step-foo-foo1-env1-unique-0':
'step-foo-foo-env1',
'step-foo-foo1-env-specific':
'step-foo-foo-env1',
'default-overriden-by-step-env-config':
'step-foo-foo-env1',
},
'env2': {
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-env2',
'global-default-override-by-step-env-config-0':
'step-foo-foo-env2',
'step-foo-foo1-env2-unique-0':
'step-foo-foo-env2',
'step-foo-foo1-env-specific':
'step-foo-foo-env2',
'default-overriden-by-step-env-config':
'step-foo-foo-env2',
}
}
}]
}
})
config.set_step_config_overrides(
'step-foo', {
'global-default-override-by-step-config-override-0':
'step-foo-step-config-override',
'step-foo-foo1-override-by-step-override':
'step-foo-step-config-override',
'step-config-override-unique-0':
'step-config-override-unique',
'default-overriden-by-step-config-overrides':
'step-foo-step-config-override'
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
defaults = {
'default-unique': 'not-overriden-default',
'default-overriden-by-global-default': 'override-me',
'default-overriden-by-global-env-default': 'override-me',
'default-overriden-by-step-config': 'override-me',
'default-overriden-by-step-env-config': 'override-me',
'default-overriden-by-step-config-overrides': 'override-me'
}
runtime_step_config_no_given_env = sub_step.get_copy_of_runtime_step_config(
None, defaults)
self.assertEqual(
ConfigValue.convert_leaves_to_values(
runtime_step_config_no_given_env), {
'global-default-unique-0':
'global-default',
'global-default-override-by-global-env-default-0':
'global-default-override-me',
'global-default-override-by-step-config-0':
'step-foo-foo1',
'global-default-override-by-step-env-config-0':
'global-default-override-me',
'step-foo-foo1-unique-0':
'step-foo-foo1',
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-override-me',
'global-default-override-by-step-config-override-0':
'step-foo-step-config-override',
'step-foo-foo1-override-by-step-override':
'step-foo-step-config-override',
'step-config-override-unique-0':
'step-config-override-unique',
'global-env-default-override-by-step-config':
'step-foo-foo1',
'default-unique':
'not-overriden-default',
'default-overriden-by-global-default':
'global-default',
'default-overriden-by-global-env-default':
'override-me',
'default-overriden-by-step-config':
'step-foo-foo1',
'default-overriden-by-step-env-config':
'override-me',
'default-overriden-by-step-config-overrides':
'step-foo-step-config-override'
})
runtime_step_config_env1 = sub_step.get_copy_of_runtime_step_config(
'env1', defaults)
self.assertEqual(
ConfigValue.convert_leaves_to_values(runtime_step_config_env1), {
'environment-name':
'env1',
'global-default-unique-0':
'global-default',
'global-default-override-by-global-env-default-0':
'global-environment-defaults-1',
'global-default-override-by-step-config-0':
'step-foo-foo1',
'global-default-override-by-step-env-config-0':
'step-foo-foo-env1',
'step-foo-foo1-unique-0':
'step-foo-foo1',
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-env1',
'global-default-override-by-step-config-override-0':
'step-foo-step-config-override',
'step-foo-foo1-override-by-step-override':
'step-foo-step-config-override',
'step-config-override-unique-0':
'step-config-override-unique',
'global-env-default-override-by-step-config':
'step-foo-foo1',
'global-env-default-env1-unique-0':
'global-environment-defaults-1',
'step-foo-foo1-env1-unique-0':
'step-foo-foo-env1',
'step-foo-foo1-env-specific':
'step-foo-foo-env1',
'default-unique':
'not-overriden-default',
'default-overriden-by-global-default':
'global-default',
'default-overriden-by-global-env-default':
'global-environment-defaults-1',
'default-overriden-by-step-config':
'step-foo-foo1',
'default-overriden-by-step-env-config':
'step-foo-foo-env1',
'default-overriden-by-step-config-overrides':
'step-foo-step-config-override'
})
runtime_step_config_env2 = sub_step.get_copy_of_runtime_step_config(
'env2', defaults)
self.assertEqual(
ConfigValue.convert_leaves_to_values(runtime_step_config_env2), {
'environment-name':
'env2',
'global-default-unique-0':
'global-default',
'global-default-override-by-global-env-default-0':
'global-environment-defaults-2',
'global-default-override-by-step-config-0':
'step-foo-foo1',
'global-default-override-by-step-env-config-0':
'step-foo-foo-env2',
'step-foo-foo1-unique-0':
'step-foo-foo1',
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-env2',
'global-default-override-by-step-config-override-0':
'step-foo-step-config-override',
'step-foo-foo1-override-by-step-override':
'step-foo-step-config-override',
'step-config-override-unique-0':
'step-config-override-unique',
'global-env-default-override-by-step-config':
'step-foo-foo1',
'global-env-default-env2-unique-0':
'global-environment-defaults-2',
'step-foo-foo1-env2-unique-0':
'step-foo-foo-env2',
'step-foo-foo1-env-specific':
'step-foo-foo-env2',
'default-unique':
'not-overriden-default',
'default-overriden-by-global-default':
'global-default',
'default-overriden-by-global-env-default':
'global-environment-defaults-2',
'default-overriden-by-step-config':
'step-foo-foo1',
'default-overriden-by-step-env-config':
'step-foo-foo-env2',
'default-overriden-by-step-config-overrides':
'step-foo-step-config-override'
})
def test_get_config_value(self):
config = Config({
Config.CONFIG_KEY: {
'global-defaults': {
'global-default-unique-0':
'global-default',
'global-default-override-by-global-env-default-0':
'global-default-override-me',
'global-default-override-by-step-config-0':
'global-default-override-me',
'global-default-override-by-step-env-config-0':
'global-default-override-me',
'global-default-override-by-step-config-override-0':
'global-default-override-me'
},
'global-environment-defaults': {
'env1': {
'global-default-override-by-global-env-default-0':
'global-environment-defaults-1',
'global-env-default-env1-unique-0':
'global-environment-defaults-1',
'global-env-default-override-by-step-config':
'global-environment-defaults-1'
},
'env2': {
'global-default-override-by-global-env-default-0':
'global-environment-defaults-2',
'global-env-default-env2-unique-0':
'global-environment-defaults-2',
'global-env-default-override-by-step-config':
'global-environment-defaults-1'
}
},
'step-foo': [{
'implementer': 'foo1',
'config': {
'step-foo-foo1-unique-0':
'step-foo-foo1',
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-override-me',
'step-foo-foo1-override-by-step-override':
'step-foo-foo-override-me',
'global-default-override-by-step-config-0':
'step-foo-foo1',
'global-env-default-override-by-step-config':
'step-foo-foo1'
},
'environment-config': {
'env1': {
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-env1',
'global-default-override-by-step-env-config-0':
'step-foo-foo-env1',
'step-foo-foo1-env1-unique-0': 'step-foo-foo-env1',
'step-foo-foo1-env-specific': 'step-foo-foo-env1'
},
'env2': {
'step-foo-foo1-override-by-step-env-config':
'step-foo-foo-env2',
'global-default-override-by-step-env-config-0':
'step-foo-foo-env2',
'step-foo-foo1-env2-unique-0': 'step-foo-foo-env2',
'step-foo-foo1-env-specific': 'step-foo-foo-env2'
}
}
}]
}
})
config.set_step_config_overrides(
'step-foo', {
'global-default-override-by-step-config-override-0':
'step-foo-step-config-override',
'step-foo-foo1-override-by-step-override':
'step-foo-step-config-override',
'step-config-override-unique-0': 'step-config-override-unique'
})
step_config = config.get_step_config('step-foo')
sub_step = step_config.get_sub_step('foo1')
self.assertEqual(sub_step.get_config_value('global-default-unique-0'),
"global-default")
self.assertEqual(
sub_step.get_config_value(
'global-default-override-by-global-env-default-0'),
"global-default-override-me")
self.assertEqual(
sub_step.get_config_value(
'global-default-override-by-global-env-default-0', 'env1'),
"global-environment-defaults-1")
self.assertEqual(
sub_step.get_config_value(
'global-default-override-by-global-env-default-0', 'env2'),
"global-environment-defaults-2")
self.assertEqual(
sub_step.get_config_value(
'global-default-override-by-step-config-0'), "step-foo-foo1")
self.assertEqual(
sub_step.get_config_value(
'global-default-override-by-step-config-0', 'env1'),
"step-foo-foo1")
self.assertEqual(sub_step.get_config_value('step-foo-foo1-unique-0', ),
"step-foo-foo1")
self.assertEqual(
sub_step.get_config_value('step-foo-foo1-unique-0', 'env1'),
"step-foo-foo1")
self.assertEqual(
sub_step.get_config_value(
'step-foo-foo1-override-by-step-env-config', ),
"step-foo-foo-override-me")
self.assertEqual(
sub_step.get_config_value(
'step-foo-foo1-override-by-step-env-config', 'env1'),
"step-foo-foo-env1")
self.assertEqual(
sub_step.get_config_value(
'step-foo-foo1-override-by-step-env-config', 'env2'),
"step-foo-foo-env2")
self.assertIsNone(sub_step.get_config_value('does-not-exist'))
