def test_multiple_parameters_get_required(self):
self.add_parameter(create_parameter_model('p1'))
self.add_parameter(create_parameter_model('p2'))
self.add_parameter(create_parameter_model('p3'))
property = self.create_property('Hello ${p1}, ${p3} and ${p2}!')
self.assertCountEqual(['p1', 'p2', 'p3'], property.required_parameters)
def test_multiple_parameters_when_one_repeats(self):
self.add_parameter(create_parameter_model('p1'))
self.add_parameter(create_parameter_model('p2'))
property = self.create_property('Hello ${p1}, ${p1}, ${p2} and ${p1}!')
self.set_value('p1', 'John')
self.set_value('p2', 'Mary')
self.assertEqual('Hello John, John, Mary and John!', property.get())
def test_two_replaces_in_two_files(self):
parameters = []
parameters.append(create_parameter_model('param1', all_parameters=parameters))
parameters.append(create_parameter_model('param2', all_parameters=parameters))
files = file_download_feature.substitute_parameter_values(
parameters,
['/home/${param2}/${param1}.txt', '/tmp/${param2}.txt', '/${param1}'],
{'param1': 'val1', 'param2': 'val2'})
self.assertEqual(files, ['/home/val2/val1.txt', '/tmp/val2.txt', '/val1'])
def test_multiple_parameters_when_one_missing(self):
self.add_parameter(create_parameter_model('p1'))
self.add_parameter(create_parameter_model('p2'))
self.add_parameter(create_parameter_model('p3'))
property = self.create_property('Hello, ${p1}, ${p2} and ${p3}!')
self.set_value('p1', 'John')
self.set_value('p3', 'world')
self.assertIsNone(property.get())
def test_multiple_parameters(self):
self.add_parameter(create_parameter_model('p1'))
self.add_parameter(create_parameter_model('p2'))
self.add_parameter(create_parameter_model('p3'))
property = self.create_property('Hello, ${p1}, ${p2} and ${p3}!')
self.set_value('p1', 'John')
self.set_value('p2', 'Mary')
self.set_value('p3', 'world')
self.assertEqual('Hello, John, Mary and world!', property.get())
def test_list_with_dependency_when_matches(self):
parameters = []
values = ObservableDict()
dep_param = create_parameter_model('dep_param')
parameter = create_parameter_model('param',
type='list',
values_script="echo '${dep_param}_\n' '_${dep_param}_'",
all_parameters=parameters,
other_param_values=values)
parameters.extend([dep_param, parameter])
values['dep_param'] = 'abc'
error = parameter.validate_value(' _abc_')
self.assertIsNone(error)
def test_map_to_script_file_value(self):
file_dir = os.path.expanduser('~')
parameter_model = create_parameter_model('param1', type=PARAM_TYPE_SERVER_FILE,
file_dir=file_dir)
mapped_value = parameter_model.map_to_script('abc')
self.assertEqual(os.path.join(file_dir, 'abc'), mapped_value)
def create_parameters(self, *names):
result = []
for name in names:
parameter = create_parameter_model(name, all_parameters=result)
result.append(parameter)
return result
def test_late_add_single_parameter(self):
self.set_value('p1', 'John')
property = self.create_property('Hello, ${p1}!')
self.add_parameter(create_parameter_model('p1'))
self.assertEqual('Hello, John!', property.get())
def test_server_file_when_valid(self):
filename = 'file1.txt'
test_utils.create_file(filename)
parameter = create_parameter_model('param', type=PARAM_TYPE_SERVER_FILE, file_dir=test_utils.temp_folder)
error = parameter.validate_value(filename)
self.assertIsNone(error)
def test_single_replace(self):
parameter = create_parameter_model('param1')
files = file_download_feature.substitute_parameter_values(
[parameter],
['/home/user/${param1}.txt'],
{'param1': 'val1'})
self.assertEqual(files, ['/home/user/val1.txt'])
def test_no_pattern_match(self):
param1 = create_parameter_model('param1')
files = file_download_feature.substitute_parameter_values(
[param1],
['/home/user/${paramX}.txt'],
{'param1': 'val1'})
self.assertEqual(files, ['/home/user/${paramX}.txt'])
def test_default_settings(self):
parameter_model = create_parameter_model('param_with_defaults')
self.assertEqual('param_with_defaults', parameter_model.name)
self.assertEqual(False, parameter_model.no_value)
self.assertEqual(False, parameter_model.required)
self.assertEqual(False, parameter_model.secure)
self.assertEqual(',', parameter_model.separator)
self.assertEqual('text', parameter_model.type)
self.assertEqual(False, parameter_model.constant)
def test_notification_on_parameter_add(self):
config = _create_config_model('conf_x')
observer = self._create_collection_observer()
config.parameters.subscribe(observer)
parameter = create_parameter_model('param1')
config.parameters.append(parameter)
self.assertEqual([('add', parameter)], observer.changes)
def test_late_remove_single_parameter(self):
parameter = create_parameter_model('p1')
self.add_parameter(parameter)
self.set_value('p1', 'John')
property = self.create_property('Hello, ${p1}!')
self.parameters.remove(parameter)
self.assertEqual('Hello, ${p1}!', property.get())
def test_skip_flag_replace(self):
param1 = create_parameter_model('param1', no_value=True)
files = file_download_feature.substitute_parameter_values(
[param1],
['/home/user/${param1}.txt'],
{'param1': 'val1'})
self.assertEqual(files, ['/home/user/${param1}.txt'])
def test_server_file_when_valid(self):
filename = 'file1.txt'
test_utils.create_file(filename)
parameter = create_parameter_model('param',
type=PARAM_TYPE_SERVER_FILE,
file_dir=test_utils.temp_folder)
error = parameter.validate_value(filename)
self.assertIsNone(error)
def create_parameters_supplier(self, *param_names):
result = []
for param_name in param_names:
parameter = create_parameter_model(param_name,
all_parameters=result)
parameter.name = param_name
result.append(parameter)
return lambda: result
def test_fill_when_server_file_plain(self):
parameters = [
create_parameter_model('p1',
type='server_file',
file_dir=test_utils.temp_folder,
file_recursive=True)
]
result = fill_parameter_values(parameters, 'Value = ${p1}',
{'p1': 'folder'})
self.assertEqual('Value = folder', result)
def test_replace_username_and_param(self):
param1 = create_parameter_model('param1')
files = file_download_feature.substitute_variable_values(
[param1],
['/home/${auth.username}/${param1}.txt'],
{'param1': 'val1'},
'127.0.0.1',
'user_X')
self.assertEqual(files, ['/home/user_X/val1.txt'])
def test_no_pattern_match(self):
param1 = create_parameter_model('param1')
files = file_download_feature.substitute_variable_values(
[param1],
['/home/user/${paramX}.txt'],
{'param1': 'val1'},
'127.0.0.1',
'user_X')
self.assertEqual(files, ['/home/user/${paramX}.txt'])
def test_skip_secure_replace(self):
param1 = create_parameter_model('param1', secure=True)
files = file_download_feature.substitute_variable_values(
[param1],
['/home/user/${param1}.txt'],
{'param1': 'val1'},
'127.0.0.1',
'user_X')
self.assertEqual(files, ['/home/user/${param1}.txt'])
def test_replace_audit_name(self):
param1 = create_parameter_model('param1', no_value=True)
files = file_download_feature.substitute_variable_values(
[param1],
['/home/user/${auth.audit_name}.txt'],
{'param1': 'val1'},
'127.0.0.1',
'user_X')
self.assertEqual(files, ['/home/user/127.0.0.1.txt'])
def test_fill_when_server_file_recursive_and_one_level(self):
parameters = [
create_parameter_model('p1',
type='server_file',
file_dir=test_utils.temp_folder,
file_recursive=True)
]
result = fill_parameter_values(parameters, 'Value = ${p1}',
{'p1': ['folder']})
expected_value = os.path.join(test_utils.temp_folder, 'folder')
self.assertEqual('Value = ' + expected_value, result)
def test_prepare_only_multiselect(self):
parameters = []
param1 = create_parameter_model('param1',
type='text',
all_parameters=parameters)
multi_param = create_parameter_model('multi_param',
type='multiselect',
all_parameters=parameters)
param2 = create_parameter_model('param2',
type='list',
all_parameters=parameters)
parameters.extend([param1, multi_param, param2])
values = self.prepare({
param1: 'xyz',
multi_param: 'xyz',
param2: 'xyz'
})
self.assertEqual('xyz', values['param1'])
self.assertEqual(['xyz'], values['multi_param'])
self.assertEqual('xyz', values['param2'])
def test_ip6_when_ip4(self):
parameter = create_parameter_model('param', type='ip6')
error = parameter.validate_value('172.13.0.15')
self.assert_error(error)
def test_server_file_when_wrong(self):
test_utils.create_file('file1.txt')
parameter = create_parameter_model('param', type=PARAM_TYPE_SERVER_FILE, file_dir=test_utils.temp_folder)
error = parameter.validate_value('my.dat')
self.assert_error(error)
def test_any_ip_when_wrong(self):
parameter = create_parameter_model('param', type='ip')
error = parameter.validate_value('127.abcd.1')
self.assert_error(error)
def test_ip4_when_ip6(self):
parameter = create_parameter_model('param', type='ip4')
error = parameter.validate_value('ABCD::1234')
self.assert_error(error)
def test_multiselect_when_single_not_matching_element(self):
parameter = create_parameter_model(
'param', type=PARAM_TYPE_MULTISELECT, allowed_values=['val1', 'val2', 'val3'])
error = parameter.validate_value(['X'])
self.assert_error(error)
def test_any_ip_when_ip4(self):
parameter = create_parameter_model('param', type='ip')
error = parameter.validate_value('127.0.0.1')
self.assertIsNone(error)
def test_ip6_when_ip4(self):
parameter = create_parameter_model('param', type='ip6')
error = parameter.validate_value('172.13.0.15')
self.assert_error(error)
def test_normalize_simple_when_number(self):
parameter = create_parameter_model('param')
self.assertEqual(123, parameter.normalize_user_value(123))
def test_server_file_when_wrong(self):
test_utils.create_file('file1.txt')
parameter = create_parameter_model('param', type=PARAM_TYPE_SERVER_FILE, file_dir=test_utils.temp_folder)
error = parameter.validate_value('my.dat')
self.assert_error(error)
def test_ip6_when_complex_valid(self):
parameter = create_parameter_model('param', type='ip6')
error = parameter.validate_value('AbC:0::13:127.0.0.1')
self.assertIsNone(error)
def test_normalize_simple_when_none(self):
parameter = create_parameter_model('param')
self.assertIsNone(parameter.normalize_user_value(None))
def test_normalize_simple_when_string(self):
parameter = create_parameter_model('param')
self.assertEqual('abc', parameter.normalize_user_value('abc'))
def test_normalize_multiselect_when_none(self):
parameter = create_parameter_model('param', type=PARAM_TYPE_MULTISELECT, allowed_values=['Hello', 'world'])
self.assertEqual([], parameter.normalize_user_value(None))
def test_normalize_simple_when_string(self):
parameter = create_parameter_model('param')
self.assertEqual('abc', parameter.normalize_user_value('abc'))
def test_ip6_when_valid(self):
parameter = create_parameter_model('param', type='ip6')
error = parameter.validate_value('1:2:3:4:5:6:7:8')
self.assertIsNone(error)
def test_normalize_simple_when_list(self):
parameter = create_parameter_model('param')
self.assertEqual(['Hello', 'world'], parameter.normalize_user_value(['Hello', 'world']))
def test_ip4_when_ip6(self):
parameter = create_parameter_model('param', type='ip4')
error = parameter.validate_value('ABCD::1234')
self.assert_error(error)
def test_multiselect_when_not_list_value(self):
parameter = create_parameter_model(
'param', type=PARAM_TYPE_MULTISELECT, allowed_values=['val1', 'val2', 'val3'])
error = parameter.validate_value('val1')
self.assert_error(error)
def test_ip4_when_valid(self):
parameter = create_parameter_model('param', type='ip4')
error = parameter.validate_value('192.168.0.13')
self.assertIsNone(error)
def test_list_with_script_when_matches_and_win_newline(self):
parameter = create_parameter_model('param', type='list', values_script="echo '123\r\n' 'abc'")
error = parameter.validate_value('123')
self.assertIsNone(error)
def test_any_ip_when_wrong(self):
parameter = create_parameter_model('param', type='ip')
error = parameter.validate_value('127.abcd.1')
self.assert_error(error)
def test_any_ip_when_ip6(self):
parameter = create_parameter_model('param', type='ip')
error = parameter.validate_value('ABCD::6789')
self.assertIsNone(error)
def test_any_ip_when_ip6(self):
parameter = create_parameter_model('param', type='ip')
error = parameter.validate_value('ABCD::6789')
self.assertIsNone(error)
def test_ip4_when_valid(self):
parameter = create_parameter_model('param', type='ip4')
error = parameter.validate_value('192.168.0.13')
self.assertIsNone(error)
def test_any_ip_when_ip4(self):
parameter = create_parameter_model('param', type='ip')
error = parameter.validate_value('127.0.0.1')
self.assertIsNone(error)
def test_ip6_when_valid(self):
parameter = create_parameter_model('param', type='ip6')
error = parameter.validate_value('1:2:3:4:5:6:7:8')
self.assertIsNone(error)
def test_file_upload_parameter_when_valid(self):
parameter = create_parameter_model('param', type='file_upload')
uploaded_file = test_utils.create_file('test.xml')
error = parameter.validate_value(uploaded_file)
self.assertIsNone(error)
def test_ip6_when_complex_valid(self):
parameter = create_parameter_model('param', type='ip6')
error = parameter.validate_value('AbC:0::13:127.0.0.1')
self.assertIsNone(error)
def test_file_upload_parameter_when_not_exists(self):
parameter = create_parameter_model('param', type='file_upload')
uploaded_file = test_utils.create_file('test.xml')
error = parameter.validate_value(uploaded_file + '_')
self.assert_error(error)
def test_normalize_simple_when_none(self):
parameter = create_parameter_model('param')
self.assertIsNone(parameter.normalize_user_value(None))
def test_list_parameter_when_not_matches(self):
parameter = create_parameter_model(
'param', type='list', allowed_values=['val1', 'val2', 'val3'])
error = parameter.validate_value('val4')
self.assert_error(error)
def test_normalize_simple_when_number(self):
parameter = create_parameter_model('param')
self.assertEqual(123, parameter.normalize_user_value(123))
def test_multiselect_when_empty_list(self):
parameter = create_parameter_model(
'param', type=PARAM_TYPE_MULTISELECT, allowed_values=['val1', 'val2', 'val3'])
error = parameter.validate_value([])
self.assertIsNone(error)
def test_normalize_multiselect_when_none(self):
parameter = create_parameter_model('param', type=PARAM_TYPE_MULTISELECT, allowed_values=['Hello', 'world'])
self.assertEqual([], parameter.normalize_user_value(None))
def test_normalize_simple_when_list(self):
parameter = create_parameter_model('param')
self.assertEqual(['Hello', 'world'], parameter.normalize_user_value(['Hello', 'world']))
