def test_logging_values(self):
param1 = create_script_param_config('p1')
param2 = create_script_param_config('p2', param='-x')
param3 = create_script_param_config('p3', param='-y', no_value=True)
param4 = create_script_param_config('p4', param='-z', type='int')
config_model = create_config_model(
'my_script', script_command='echo', parameters=[param1, param2, param3, param4])
execution_id = self.executor_service.start_script(
config_model,
{'p1': 'abc', 'p3': True, 'p4': 987},
'userX',
create_audit_names(ip='localhost', auth_username='******'))
executor = self.executor_service.get_active_executor(execution_id)
executor.process_wrapper._write_script_output('some text\n')
executor.process_wrapper._write_script_output('another text')
executor.process_wrapper.finish(0)
wait_observable_close_notification(executor.get_anonymized_output_stream(), 2)
entry = self.logging_service.find_history_entry(execution_id)
self.assertIsNotNone(entry)
self.assertEqual('userX', entry.user_id)
self.assertEqual('sandy', entry.user_name)
self.assertEqual('my_script', entry.script_name)
self.assertEqual('echo abc -y -z 987', entry.command)
self.assertEqual('my_script', entry.script_name)
log = self.logging_service.find_log(execution_id)
self.assertEqual('some text\nanother text', log)
def test_parameter_secure_value_and_same_unsecure(self):
p1 = create_script_param_config('p1', param='-p1', secure=True)
p2 = create_script_param_config('p2', param='-p2')
secure_command = self.get_secure_command([p1, p2], {'p1': 'value', 'p2': 'value'})
self.assertEqual('ls -p1 ****** -p2 value', secure_command)
def test_get_parameter_values_when_invalid_value(self):
parameters = [
create_script_param_config('p1', type='int'),
create_script_param_config('dependant', type='list', values_script='echo "${p1}"')
]
config_model = _create_config_model('conf_x', parameters=parameters)
self.assertRaises(InvalidValueException, config_model.set_param_value, 'p1', 'ABC')
def test_set_all_values_when_dependants_cylce(self):
parameters = [
create_script_param_config('p1', type='list', values_script='echo "X${p2}X"'),
create_script_param_config('p2', type='list', values_script='echo "X${p1}X"')]
config_model = _create_config_model('main_conf', parameters=parameters)
values = {'p1': 'XabcX', 'p2': 'abc'}
self.assertRaisesRegex(Exception, 'Could not resolve order', config_model.set_all_param_values, values)
def test_get_required_parameters(self):
parameters = [
create_script_param_config('p1'),
create_script_param_config('dependant', type='list', values_script='echo "${p1}""${p2}"'),
create_script_param_config('p2')
]
config_model = _create_config_model('conf_x', parameters=parameters)
dependant_parameter = config_model.find_parameter('dependant')
self.assertCountEqual(['p1', 'p2'], dependant_parameter.get_required_parameters())
def test_set_all_values_with_normalization(self):
allowed_values = ['abc', 'def', 'xyz']
parameters = [
create_script_param_config('p1', type=PARAM_TYPE_MULTISELECT, allowed_values=allowed_values),
create_script_param_config('p2', type=PARAM_TYPE_MULTISELECT, allowed_values=allowed_values),
create_script_param_config('p3', type=PARAM_TYPE_MULTISELECT, allowed_values=allowed_values)]
config_model = _create_config_model('config', parameters=parameters)
config_model.set_all_param_values({'p1': '', 'p2': ['def'], 'p3': 'abc'})
self.assertEqual({'p1': [], 'p2': ['def'], 'p3': ['abc']}, config_model.parameter_values)
def test_set_all_values_when_dependant_before_required(self):
parameters = [
create_script_param_config('dep_p2', type='list', values_script='echo "X${p1}X"'),
create_script_param_config('p1')]
config_model = _create_config_model('main_conf', parameters=parameters)
values = {'dep_p2': 'XabcX', 'p1': 'abc'}
config_model.set_all_param_values(values)
self.assertEqual(values, config_model.parameter_values)
def test_create_with_parameters_and_default_values(self):
parameters = [create_script_param_config('param1', default='123'),
create_script_param_config('param2'),
create_script_param_config('param3', default='A')]
config_model = _create_config_model('conf_with_defaults', parameters=parameters)
self.assertEqual(3, len(config_model.parameters))
values = config_model.parameter_values
self.assertEqual('123', values.get('param1'))
self.assertIsNone(values.get('param2'))
self.assertEqual('A', values.get('param3'))
def test_dynamic_include_add_2_parameters_with_default_when_one_dependant(self):
(config_model, included_path) = self.prepare_config_model_with_included([
create_script_param_config('included_param1', default='ABC'),
create_script_param_config('included_param2', default='xABCx', type='list',
values_script='echo x${included_param1}x'),
], 'p1')
self.assertEqual('ABC', config_model.parameter_values.get('included_param1'))
self.assertEqual('xABCx', config_model.parameter_values.get('included_param2'))
dependant_parameter = config_model.find_parameter('included_param2')
self.assertEqual(['xABCx'], dependant_parameter.values)
def test_dynamic_include_remove_multiple_parameters(self):
(config_model, included_path) = self.prepare_config_model_with_included([
create_script_param_config('included_param1'),
create_script_param_config('included_param2'),
create_script_param_config('included_param3')
], 'p1')
config_model.set_param_value('p1', '')
self.assertEqual(1, len(config_model.parameters))
included_param = config_model.parameters[0]
self.assertEqual('p1', included_param.name)
def test_static_include_ignore_same_parameter(self):
included_path = test_utils.write_script_config({'parameters': [
create_script_param_config('param1', type='int', required=False)
]}, 'included')
config_model = _create_config_model('main_conf', config={
'include': included_path,
'parameters': [create_script_param_config('param1', type='text', required=True)]})
self.assertEqual(1, len(config_model.parameters))
param1 = config_model.parameters[0]
self.assertEqual('text', param1.type)
self.assertEqual(True, param1.required)
def test_get_parameter_values_simple(self):
parameters = [
create_script_param_config('p1'),
create_script_param_config('dependant',
type='list',
values_script="echo '${p1}\n' '_${p1}_\n' '${p1}${p1}\n'")
]
config_model = _create_config_model('conf_x', parameters=parameters)
config_model.set_param_value('p1', 'ABC')
dependant_parameter = config_model.find_parameter('dependant')
self.assertEqual(['ABC', ' _ABC_', ' ABCABC'], dependant_parameter.values)
def test_create_with_parameters_and_custom_values(self):
parameters = [create_script_param_config('param1', default='def1'),
create_script_param_config('param2', default='def2'),
create_script_param_config('param3', default='def3')]
parameter_values = {'param1': '123', 'param3': True}
config_model = _create_config_model('conf_with_defaults', parameters=parameters,
parameter_values=parameter_values)
self.assertEqual(3, len(config_model.parameters))
values = config_model.parameter_values
self.assertEqual('123', values.get('param1'))
self.assertIsNone(values.get('param2'))
self.assertEqual(True, values.get('param3'))
def test_dynamic_include_replace(self):
(config_model, included_path1) = self.prepare_config_model_with_included([
create_script_param_config('included_param_X')
], 'p1')
included_path2 = test_utils.write_script_config({'parameters': [
create_script_param_config('included_param_Y')
]}, 'included2')
config_model.set_param_value('p1', included_path2)
self.assertEqual(2, len(config_model.parameters))
self.assertEqual('p1', config_model.parameters[0].name)
self.assertEqual('included_param_Y', config_model.parameters[1].name)
def test_output_files_with_secure_parameters(self):
test_utils.create_file('file1.txt', text='hello world')
file2 = test_utils.create_file(os.path.join('sub', 'child', 'admin.log'), text='password=123')
param1 = create_script_param_config('p1', secure=True)
param2 = create_script_param_config('p2')
downloadable_files = self.perform_execution([
os.path.join(test_utils.temp_folder, '${p1}.txt'),
os.path.join(test_utils.temp_folder, 'sub', '${p2}', 'admin.log')],
parameter_values={'p1': 'file1', 'p2': 'child'},
parameters=[param1, param2])
self.assert_downloadable_files(downloadable_files, [file2])
def test_dynamic_include_replace(self):
(config_model, included_path1) = self.prepare_config_model_with_included([
create_script_param_config('included_param_X')
], 'p1')
included_path2 = test_utils.write_script_config({'parameters': [
create_script_param_config('included_param_Y')
]}, 'included2')
config_model.set_param_value('p1', included_path2)
self.assertEqual(2, len(config_model.parameters))
self.assertEqual('p1', config_model.parameters[0].name)
self.assertEqual('included_param_Y', config_model.parameters[1].name)
def test_set_all_values_for_included(self):
included_path = test_utils.write_script_config({'parameters': [
create_script_param_config('included_param1'),
create_script_param_config('included_param2')
]}, 'included')
config_model = _create_config_model(
'main_conf',
config={
'include': '${p1}',
'parameters': [create_script_param_config('p1')]})
values = {'p1': included_path, 'included_param1': 'X', 'included_param2': 123}
config_model.set_all_param_values(values)
self.assertEqual(values, config_model.parameter_values)
def test_dynamic_include_add_parameter(self):
included_path = test_utils.write_script_config(
{'parameters': [create_script_param_config('included_param')]},
'included')
config_model = _create_config_model(
'main_conf',
config={
'include': '${p1}',
'parameters': [create_script_param_config('p1')]
})
config_model.set_param_value('p1', included_path)
self.assertEqual(2, len(config_model.parameters))
included_param = config_model.parameters[1]
self.assertEqual('included_param', included_param.name)
def test_get_parameter_values_simple(self):
parameters = [
create_script_param_config('p1'),
create_script_param_config(
'dependant',
type='list',
values_script="echo '${p1}\n' '_${p1}_\n' '${p1}${p1}\n'")
]
config_model = _create_config_model('conf_x', parameters=parameters)
config_model.set_param_value('p1', 'ABC')
dependant_parameter = config_model.find_parameter('dependant')
self.assertEqual(['ABC', ' _ABC_', ' ABCABC'],
dependant_parameter.values)
def test_set_all_values_when_dependants_cylce(self):
parameters = [
create_script_param_config('p1',
type='list',
values_script='echo "X${p2}X"'),
create_script_param_config('p2',
type='list',
values_script='echo "X${p1}X"')
]
config_model = _create_config_model('main_conf', parameters=parameters)
values = {'p1': 'XabcX', 'p2': 'abc'}
self.assertRaisesRegex(Exception, 'Could not resolve order',
config_model.set_all_param_values, values)
def test_set_all_values_for_included(self):
included_path = test_utils.write_script_config({'parameters': [
create_script_param_config('included_param1'),
create_script_param_config('included_param2')
]}, 'included')
config_model = _create_config_model(
'main_conf',
config={
'include': '${p1}',
'parameters': [create_script_param_config('p1')]})
values = {'p1': included_path, 'included_param1': 'X', 'included_param2': 123}
config_model.set_all_param_values(values)
self.assertEqual(values, config_model.parameter_values)
def test_one_parameter_no_values(self):
config = create_config_model(
'config_x', parameters=[create_script_param_config('param1')])
args_string = executor.build_command_args({}, config)
self.assertEqual(args_string, [])
def test_one_parameter_one_value(self):
config = create_config_model(
'config_x', parameters=[create_script_param_config('p1')])
args_string = self.build_command_args({'p1': 'value'}, config)
self.assertEqual(['value'], args_string)
def test_dynamic_include_wrong_path(self):
config_model = _create_config_model('main_conf', config={
'include': '${p1}',
'parameters': [create_script_param_config('p1')]})
config_model.set_param_value('p1', 'some path')
self.assertEqual(1, len(config_model.parameters))
def test_parameter_multiselect_when_empty_list(self):
parameter = create_script_param_config('p1', param='-p1', type=PARAM_TYPE_MULTISELECT)
config = create_config_model('config_x', parameters=[parameter])
args_list = self.build_command_args({'p1': []}, config)
self.assertEqual([], args_list)
def test_static_include_single_parameter(self):
included_path = test_utils.write_script_config({'parameters': [
create_script_param_config('param2', type='int')
]}, 'included')
config_model = _create_config_model('main_conf', config={
'include': included_path,
'parameters': [create_script_param_config('param1', type='text')]})
self.assertEqual(2, len(config_model.parameters))
param1 = config_model.parameters[0]
self.assertEqual('param1', param1.name)
self.assertEqual('text', param1.type)
param2 = config_model.parameters[1]
self.assertEqual('param2', param2.name)
self.assertEqual('int', param2.type)
def test_get_parameter_values_when_replace_correct_with_invalid_value(self):
parameters = [
create_script_param_config('p1', type='int'),
create_script_param_config('dependant', type='list', values_script='echo "${p1}"')
]
config_model = _create_config_model('conf_x', parameters=parameters)
dependant_parameter = config_model.find_parameter('dependant')
config_model.set_param_value('p1', 12345)
self.assertEqual(['12345'], dependant_parameter.values)
try:
config_model.set_param_value('p1', 'ABC')
self.fail('Invalid value was set, this should not be possible')
except InvalidValueException:
self.assertEqual([], dependant_parameter.values)
def test_set_value_for_unknown_parameter(self):
param1 = create_script_param_config('param1')
config_model = _create_config_model('conf_x', parameters=[param1])
config_model.set_param_value('PAR_2', 'abc')
self.assertNotIn('PAR_2', config_model.parameter_values)
def test_create_with_parameters_and_custom_values(self):
parameters = [
create_script_param_config('param1', default='def1'),
create_script_param_config('param2', default='def2'),
create_script_param_config('param3', default='def3')
]
parameter_values = {'param1': '123', 'param3': True}
config_model = _create_config_model('conf_with_defaults',
parameters=parameters,
parameter_values=parameter_values)
self.assertEqual(3, len(config_model.parameters))
values = config_model.parameter_values
self.assertEqual('123', values.get('param1'))
self.assertIsNone(values.get('param2'))
self.assertEqual(True, values.get('param3'))
def test_dynamic_include_wrong_path(self):
config_model = _create_config_model('main_conf', config={
'include': '${p1}',
'parameters': [create_script_param_config('p1')]})
config_model.set_param_value('p1', 'some path')
self.assertEqual(1, len(config_model.parameters))
def test_multiple_parameters_sequence(self):
p1 = create_script_param_config('p1', param='-p1')
p2 = create_script_param_config('p2')
p3 = create_script_param_config('p3', param='--p3', no_value=True)
p4 = create_script_param_config('p4', param='-p4')
p5 = create_script_param_config('p5')
config = create_config_model('config_x', parameters=[p1, p2, p3, p4, p5])
args_string = self.build_command_args({
'p1': 'val1',
'p2': 'val2',
'p3': 'true',
'p5': 'val5'},
config)
self.assertEqual(args_string, ['-p1', 'val1', 'val2', '--p3', 'val5'])
def test_dynamic_include_replace_with_missing_file(self):
included_path1 = test_utils.write_script_config(
{'parameters': [create_script_param_config('included_param_X')]},
'included1')
config_model = _create_config_model(
'main_conf',
config={
'include': '${p1}',
'parameters': [create_script_param_config('p1')]
})
config_model.set_param_value('p1', included_path1)
config_model.set_param_value('p1', 'a/b/c/some.txt')
self.assertEqual(1, len(config_model.parameters))
self.assertEqual('p1', config_model.parameters[0].name)
def test_parameter_constant(self):
parameter = create_script_param_config('p1', constant=True, default='const')
config = create_config_model('config_x', parameters=[parameter])
args_string = self.build_command_args({'p1': 'value'}, config)
self.assertEqual(['const'], args_string)
def test_parameter_int(self):
parameter = create_script_param_config('p1', param='-p1', type='int')
config = create_config_model('config_x', parameters=[parameter])
args_string = self.build_command_args({'p1': 5}, config)
self.assertEqual(['-p1', 5], args_string)
def test_one_parameter_with_param(self):
parameter = create_script_param_config('p1', param='-p1')
config = create_config_model('config_x', parameters=[parameter])
args_string = self.build_command_args({'p1': 'value'}, config)
self.assertEqual(['-p1', 'value'], args_string)
def test_one_parameter_flag_true(self):
parameter = create_script_param_config('p1', param='--flag', no_value=True)
config = create_config_model('config_x', parameters=[parameter])
args_string = self.build_command_args({'p1': True}, config)
self.assertEqual(['--flag'], args_string)
def test_when_parameter_multiselect_and_comma_separated(self):
parameter = create_script_param_config(
'p1', param='-p1', type=PARAM_TYPE_MULTISELECT)
secure_command = self.get_secure_command([parameter], {'p1': ['abc', 'def']})
self.assertEqual('ls -p1 abc,def', secure_command)
def test_secure_parameter_int(self):
parameter = create_script_param_config(
'p1', param='-p1', type='int', secure=True)
secure_command = self.get_secure_command([parameter], {'p1': 123})
self.assertEqual('ls -p1 ******', secure_command)
def test_parameter_no_value(self):
parameter = create_script_param_config(
'p1', param='-p1', no_value=True)
secure_command = self.get_secure_command([parameter], {'p1': True})
self.assertEqual('ls -p1', secure_command)
def test_parameter_multiselect_and_multiple_arguments(self):
parameter = create_script_param_config(
'p1', param='-p1', type=PARAM_TYPE_MULTISELECT, multiple_arguments=True)
secure_command = self.get_secure_command([parameter], {'p1': ['abc', 'def']})
self.assertEqual('ls -p1 abc def', secure_command)
def test_static_include_single_parameter(self):
included_path = test_utils.write_script_config({'parameters': [
create_script_param_config('param2', type='int')
]}, 'included')
config_model = _create_config_model('main_conf', config={
'include': included_path,
'parameters': [create_script_param_config('param1', type='text')]})
self.assertEqual(2, len(config_model.parameters))
param1 = config_model.parameters[0]
self.assertEqual('param1', param1.name)
self.assertEqual('text', param1.type)
param2 = config_model.parameters[1]
self.assertEqual('param2', param2.name)
self.assertEqual('int', param2.type)
def test_parameter_secure_multiselect_as_multiarg(self):
parameter = create_script_param_config(
'p1', param='-p1', secure=True, type=PARAM_TYPE_MULTISELECT, multiple_arguments=True)
secure_command = self.get_secure_command([parameter], {'p1': ['one', 'two', 'three']})
self.assertEqual('ls -p1 ****** ****** ******', secure_command)
def test_parameter_multiselect_when_multiple_list_as_multiarg(self):
parameter = create_script_param_config('p1', type=PARAM_TYPE_MULTISELECT, multiple_arguments=True)
config = create_config_model('config_x', parameters=[parameter])
args_list = self.build_command_args({'p1': ['val1', 'val2', 'hello world']}, config)
self.assertEqual(['val1', 'val2', 'hello world'], args_list)
def perform_execution(self,
output_files,
parameter_values=None,
parameters=None):
if parameter_values is None:
parameter_values = {}
if parameters is None:
parameters = [
create_script_param_config(key)
for key in parameter_values.keys()
]
config_model = create_config_model('my_script',
output_files=output_files,
parameters=parameters)
execution_id = self.executor_service.start_script(
config_model, parameter_values, 'userX',
create_audit_names(ip='127.0.0.1'))
self.executor_service.stop_script(execution_id)
finish_condition = threading.Event()
self.executor_service.add_finish_listener(
lambda: finish_condition.set(), execution_id)
finish_condition.wait(2)
downloadable_files = self.feature.get_downloadable_files(execution_id)
return downloadable_files
def test_dynamic_include_add_parameter(self):
(config_model,
included_path) = self.prepare_config_model_with_included(
[create_script_param_config('included_param')], 'p1')
self.assertEqual(2, len(config_model.parameters))
included_param = config_model.parameters[1]
self.assertEqual('included_param', included_param.name)
def test_dynamic_include_add_parameter_with_default(self):
(config_model,
included_path) = self.prepare_config_model_with_included(
[create_script_param_config('included_param', default='abc 123')],
'p1')
self.assertEqual('abc 123',
config_model.parameter_values.get('included_param'))
def setUp(self):
super().setUp()
self.socket = None
application = tornado.web.Application([(r'/scripts/([^/]*)', ScriptConfigSocket)],
login_url='/login.html',
cookie_secret='12345')
application.auth = TornadoAuth(None)
application.authorizer = Authorizer(ANY_USER, [], [], EmptyGroupProvider())
application.identification = IpBasedIdentification(TrustedIpValidator(['127.0.0.1']), None)
application.config_service = ConfigService(application.authorizer, test_utils.temp_folder)
server = httpserver.HTTPServer(application)
socket, self.port = testing.bind_unused_port()
server.add_socket(socket)
test_utils.setup()
for dir in ['x', 'y', 'z']:
for file in range(1, 4):
filename = dir + str(file) + '.txt'
test_utils.create_file(os.path.join('test1_files', dir, filename))
test1_files_path = os.path.join(test_utils.temp_folder, 'test1_files')
test_utils.write_script_config(
{'name': 'Test script 1',
'script_path': 'ls',
'include': '${text 1}.json',
'parameters': [
test_utils.create_script_param_config('text 1', required=True),
test_utils.create_script_param_config('list 1', type='list',
allowed_values=['A', 'B', 'C']),
test_utils.create_script_param_config('file 1', type='server_file',
file_dir=test1_files_path),
test_utils.create_script_param_config('list 2', type='list',
values_script='ls ' + test1_files_path + '/${file 1}')
]},
'test_script_1')
test_utils.write_script_config(
{
'parameters': [
test_utils.create_script_param_config('included text 2')
]},
'included')
def test_dynamic_include_relative_path(self):
folder = os.path.join(test_utils.temp_folder, 'inner', 'confs')
included_path = test_utils.write_script_config({'parameters': [
create_script_param_config('included_param')
]}, 'included', folder)
included_folder = os.path.dirname(included_path)
config_model = _create_config_model(
'main_conf',
path=os.path.join(folder, 'mainConf.json'),
config={
'include': '${p1}',
'working_directory': included_folder,
'parameters': [create_script_param_config('p1')]})
config_model.set_param_value('p1', 'included.json')
self.assertEqual(2, len(config_model.parameters))
