def test_without_optional_annotation(self):
# self.template_yamls contains multipe documents with
# references to an undefined placeholder
for index in [1, 2, 3, 4]:
try:
# should fail
replace(self.in_yamls, self.template_yamls[index])
self.assertTrue(False)
except PlaceholderNotFoundError as pnfe:
self.assertEqual('{{' + pnfe.placeholder + '}}',
self.template_yamls[index]['property1'])
except Exception as e:
self.assertTrue(False, e)
for index in [5]:
try:
# should fail
replace(self.in_yamls, self.template_yamls[index])
self.assertTrue(False)
except PlaceholderNotFoundError as pnfe:
self.assertEqual(
'{{' + pnfe.placeholder + '}}',
self.template_yamls[index].get('property1').get(
'property1a'))
except Exception as e:
self.assertTrue(False, e)
def test_none_parms(self):
try:
# one or more of the inputs is None
self.assertEqual(replace(None, None), None)
self.assertEqual(replace({}, None), None)
self.assertEqual(replace(None, {}), None)
except Exception as e:
self.assertTrue(False, e)
def generate_dlf_yaml_dict(in_yaml):
"""
Generate DLF-compatible YAML configuration using
"templates/dlf_out.yaml" as template.
:param in_yaml: dict representation of a YAML document defining
placeholder values in "templates/dlf_out.yaml"
:type in_yaml: dict
:raises PlaceholderNotFoundError: a {{...}} placeholder referenced
in "templates/dlf_out.yaml" was not found
:raises ValueError in_yaml is not of type dict
:return: DLF-compatible YAML file
:rtype: dict
"""
dlf_yaml = files(templates).joinpath('dlf_out.yaml')
# load the template YAML
dlf_template_yaml = yaml.load(dlf_yaml)
# replace placeholders in in_template_yaml with values from
# in_placeholder_yaml
dlf_yaml_dict = replace(in_yaml, dlf_template_yaml)
return dlf_yaml_dict
def test_dax_dataset_descriptors(self):
# Verify that the DAX data set descriptors in dax-data-set-descriptors
# don't raise any exceptions during processing. For example, an
# exception is raised if the DLF YAML template contains a placeholder
# that is not defined.
error_count = 0
for descriptor in glob.iglob('dax-data-set-descriptors/*.yaml'):
in_yaml = yaml.load(Path(descriptor))
try:
replace(in_yaml, self.template_yamls)
except Exception as e:
print('Error prossing {}: {}'.format(descriptor, str(e)))
error_count = error_count + 1
self.assertEqual(
error_count, 0,
'Processing of {} descriptors failed'.format(error_count))
def test_valid_parm_types(self):
try:
# inputs are empty (nothing to process)
result = replace({}, {})
# result must be an empty dict
self.assertTrue(isinstance(result, dict))
self.assertTrue(len(result.keys()) == 0)
except Exception as ex:
self.assertTrue(False, ex)
def test_lists(self):
try:
out_dict = replace(self.in_yamls, self.template_yamls)
self.assertTrue(out_dict is not None)
self.assertTrue(isinstance(out_dict, dict))
self.assertEqual(out_dict['apiVersion'], None)
self.assertEqual(out_dict['kind'], self.template_yamls['kind'])
# list of strings
self.assertIsInstance(out_dict['string_list_key'], list)
self.assertTrue(len(out_dict['string_list_key']) == 2)
self.assertSetEqual(set(out_dict['string_list_key']),
set(['item1', self.in_yamls['string_key']]))
# list of dicts (no replacement)
self.assertIsInstance(out_dict['dict_list_key'], list)
self.assertTrue(len(out_dict['dict_list_key']) == 3)
self.assertIsInstance(out_dict['dict_list_key'][0], dict)
self.assertEqual(out_dict['dict_list_key'][0]['key1'], 'value1a')
self.assertEqual(out_dict['dict_list_key'][0]['key2'], 'value2a')
self.assertEqual(out_dict['dict_list_key'][1]['key1'], 'value1b')
self.assertEqual(out_dict['dict_list_key'][2]['key1'], 'value1c')
self.assertEqual(out_dict['dict_list_key'][2]['key2'], 'value2b')
self.assertEqual(out_dict['dict_list_key'][2]['key3'], 'value3a')
# list of dicts (with replacement)
self.assertIsInstance(out_dict['dict_list_key2']['list_a'], list)
self.assertTrue(len(out_dict['dict_list_key2']['list_a']) == 3)
self.assertEqual(
out_dict['dict_list_key2']['list_a'][0]['property1'],
'value1a')
self.assertEqual(
out_dict['dict_list_key2']['list_a'][1]['property1'],
'value1b')
self.assertEqual(
out_dict['dict_list_key2']['list_a'][1]['property2'],
'value2a')
self.assertEqual(
out_dict['dict_list_key2']['list_a'][2]['property1'],
'value1c')
self.assertEqual(
out_dict['dict_list_key2']['list_a'][2]['property2'],
'value2b')
self.assertEqual(
out_dict['dict_list_key2']['list_a'][2]['property3'],
'value3a')
except Exception as e:
self.assertTrue(False, e)
def test_invalid_parm_types(self):
invalid_parm_types = [[], '']
for invalid_type in invalid_parm_types:
try:
# first input parameter type is not a dict
self.assertEqual(replace(invalid_type, {}), None)
self.assertTrue(False)
except ValueError:
pass
try:
# second input parameter type is not a dict
self.assertEqual(replace({}, invalid_type), None)
self.assertTrue(False)
except ValueError:
pass
try:
# both input parameter types are not a dict
self.assertEqual(replace(invalid_type, invalid_type), None)
self.assertTrue(False)
except ValueError:
pass
def test_dicts(self):
try:
out_dict = replace(self.in_yamls[0], self.template_yamls[0])
self.assertTrue(out_dict is not None)
self.assertTrue(isinstance(out_dict, dict))
self.assertEqual(out_dict['apiVersion'], None)
self.assertEqual(out_dict['kind'], self.template_yamls[0]['kind'])
self.assertEqual(out_dict['dict1'], self.in_yamls[0]['level0_1'])
self.assertEqual(out_dict['dict2'], self.in_yamls[0]['level0_2'])
self.assertEqual(out_dict['dict3']['key_a'],
self.in_yamls[0]['level0_3'])
self.assertEqual(out_dict['dict3']['key_b'],
self.in_yamls[0]['level0_4'])
except Exception as e:
self.assertTrue(False, e)
def test_dtest_dlf(self):
try:
out_dict = replace(self.in_yamls, self.template_yamls)
self.assertTrue(out_dict is not None)
self.assertTrue(isinstance(out_dict, dict))
self.assertEqual(out_dict['apiVersion'], 'com.ibm/v1alpha1')
self.assertEqual(out_dict['kind'], 'Dataset')
self.assertEqual(out_dict['metadata']['name'],
self.in_yamls['name'])
self.assertEqual(out_dict['metadata']['labels']['version'],
self.in_yamls['version'])
self.assertEqual(out_dict['spec']['type'], 'ARCHIVE')
self.assertEqual(out_dict['spec']['url'],
self.in_yamls['repository']['url'])
self.assertEqual(out_dict['spec']['format'],
self.in_yamls['repository']['mime_type'])
except Exception as e:
self.assertTrue(False, e)
def test_scalars(self):
try:
out_dict = replace(self.in_yamls, self.template_yamls)
self.assertTrue(out_dict is not None)
self.assertTrue(isinstance(out_dict, dict))
self.assertEqual(out_dict['apiVersion'], None)
self.assertEqual(out_dict['kind'], self.template_yamls['kind'])
self.assertEqual(out_dict['metadata'], self.in_yamls['level0_1'])
self.assertEqual(out_dict['basic'], self.template_yamls['basic'])
self.assertEqual(out_dict['anton'], None)
self.assertEqual(out_dict['delta'],
self.in_yamls['level0_3']['level1_1'])
self.assertEqual(out_dict['caesar'], self.template_yamls['caesar'])
self.assertEqual(out_dict['gamma'],
self.in_yamls['level0_3']['level1_2']['level2_1'])
except Exception as e:
self.assertTrue(False, e)
self.assertTrue(True)
def generate_oah_yaml_dict(in_yaml):
"""
Generate OpenAIHub-compatible YAML configuration using
"templates/openaihub_out.yaml" as template.
:param in_yaml: dict representation of a YAML document defining
placeholder values in "templates/openaihub_out.yaml"
:type in_yaml: dict
:raises PlaceholderNotFoundError: a {{...}} placeholder referenced
in "templates/openaihub_out.yaml" was not found
:raises ValueError in_yaml is not of type dict
:return: OpenAIHub-compatible YAML file
:rtype: dict
"""
oah_yaml = files(templates).joinpath('openaihub_out.yaml')
oah_template_yaml = yaml.load(oah_yaml)
# replace placeholders in in_template_yaml with values from
# in_placeholder_yaml
oah_yaml_dict = replace(in_yaml, oah_template_yaml)
return oah_yaml_dict
def test_optional_annotation(self):
try:
out_dict = replace(self.in_yamls, self.template_yamls[0])
self.assertTrue(out_dict is not None)
self.assertTrue(isinstance(out_dict, dict))
self.assertIsNone(out_dict['property1'])
self.assertIsNone(out_dict['property2'])
self.assertIsNone(out_dict['property3'])
self.assertIsNone(out_dict['property4'])
self.assertIsNone(out_dict['property5'])
self.assertIsNone(out_dict['property6'])
self.assertIsNone(out_dict['property7']['property8'])
self.assertIsNone(
out_dict['property9']['property10']['property11'])
self.assertEqual(out_dict['property12'][0]['property12a'],
self.in_yamls['hey']['we_are_a_match'])
self.assertIsNone(out_dict['property12'][0]['property12b'])
self.assertEqual(
self.template_yamls[0]['property12'][0]['property12c'],
out_dict['property12'][0]['property12c'])
self.assertIsNone(out_dict['property13']['property14']
['property15']['property16a'])
self.assertIsNone(out_dict['property13']['property14']
['property15']['property16b'])
self.assertIsNone(out_dict['property13']['property14']
['property15']['property16c'])
self.assertEqual(
out_dict['property13']['property14']['property17'],
self.template_yamls[0]['property13']['property14']
['property17'])
self.assertEqual(
out_dict['property13']['property14']['property18'],
self.in_yamls['hey']['we_are_a_match'])
except Exception as e:
self.assertTrue(False, e)
# /path/to/placeholder/yaml see examples in dax-data-set-descriptors/
# /path/to/template/yaml see examples in templates/
if __name__ == "__main__":
try:
if len(sys.argv) != 3:
print('Usage: {} {} {}'.format(sys.argv[0],
'/path/to/placeholder/yaml',
'/path/to/template/yaml'))
sys.exit(1)
# load the placeholder YAML
with open(sys.argv[1], 'r') as source_yaml:
in_placeholder_yaml = yaml.load(source_yaml,
Loader=yaml.FullLoader)
# load the template YAML
with open(sys.argv[2], 'r') as source_yaml:
in_template_yaml = yaml.load(source_yaml, Loader=yaml.FullLoader)
# replace placeholders in in_template_yaml with values from
# in_placeholder_yaml
out_template_yaml = replace(in_placeholder_yaml, in_template_yaml)
# print template yamls with replacements in place
print(out_template_yaml)
except Exception as ex:
print(ex)
