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_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_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_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_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 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 setUp(self):
self.config = create_config_model('config_x')
self.config.script_command = 'ls'
executor._process_creator = _MockProcessWrapper
test_utils.setup()
super().setUp()
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 = executor.build_command_args({'p1': 'value'}, config)
self.assertEqual(args_string, ['const'])
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 = executor.build_command_args({'p1': True}, config)
self.assertEqual(args_string, ['--flag'])
def test_parameter_multiselect_when_single_list_as_multiarg(self):
parameter = create_script_param_config('p1',
param='-p1',
type='multiselect')
config = create_config_model('config_x', parameters=[parameter])
args_list = executor.build_command_args({'p1': ['val1']}, config)
self.assertEqual(args_list, ['-p1', 'val1'])
def test_parameter_multiselect_when_empty_string(self):
parameter = create_script_param_config('p1',
param='-p1',
type='multiselect')
config = create_config_model('config_x', parameters=[parameter])
args_list = executor.build_command_args({'p1': ''}, config)
self.assertEqual(args_list, [])
def test_start_with_one_value(self):
config = create_config_model(
'config_x', parameters=[create_script_param_config('id')])
self.create_executor(config, {'id': 918273})
self.executor.start()
process_wrapper = self.executor.process_wrapper
self.assertEqual(['ls', 918273], process_wrapper.command)
self.assertEqual({'PARAM_ID': '918273'}, process_wrapper.env_variables)
def test_one_parameter_flag_false(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': False}, config)
self.assertEqual([], args_string)
def test_no_parameters_some_values(self):
config = create_config_model('config_x')
args_string = self.build_command_args({
'p1': 'value',
'p2': 'value'
}, config)
self.assertEqual([], args_string)
def test_parameter_multiselect_when_empty_list(self):
parameter = create_script_param_config('p1',
param='-p1',
type='multiselect')
config = create_config_model('config_x', parameters=[parameter])
args_list = self.build_command_args({'p1': []}, config)
self.assertEqual([], args_list)
def mock_schedule_model_with_secure_param(self):
model = test_utils.create_config_model('some-name',
parameters=[{
'name': 'p1',
'secure': True
}])
model.schedulable = True
self.config_service.load_config_model.side_effect = lambda a, b, c: model
def test_parameter_multiselect_when_multiple_list(self):
parameter = create_script_param_config('p1',
type=PARAM_TYPE_MULTISELECT)
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 test_parameter_multiselect_when_single_list_as_multiarg(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': ['val1']}, config)
self.assertEqual(['-p1', 'val1'], args_list)
def test_parameter_multiselect_when_empty_string(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_parameter_multiselect_when_multiple_list_as_multiarg(self):
parameter = create_script_param_config('p1',
type='multiselect',
multiple_arguments=True)
config = create_config_model('config_x', parameters=[parameter])
args_list = executor.build_command_args(
{'p1': ['val1', 'val2', 'hello world']}, config)
self.assertEqual(args_list, ['val1', 'val2', 'hello world'])
def test_parameter_int_without_space(self):
parameter = create_script_param_config('p1',
param='-p1=',
type='int',
same_arg_param=True)
config = create_config_model('config_x', parameters=[parameter])
args_string = self.build_command_args({'p1': 10}, config)
self.assertEqual(['-p1=10'], args_string)
def test_parameter_secure_some_value(self):
parameter = create_script_param_config('p1', param='-p1', secure=True)
config = create_config_model('config_x',
config={'script_path': 'ls'},
parameters=[parameter])
executor = ScriptExecutor(config, {'p1': 'value'})
secure_command = executor.get_secure_command()
self.assertEqual('ls -p1 ******', secure_command)
def test_start_logging_on_execution_start(self):
execution_id = self.executor_service.start_script(
create_config_model('my_script'), {}, 'userX',
create_audit_names(ip='localhost'))
executor = self.executor_service.get_active_executor(execution_id)
executor.process_wrapper.finish(0)
entry = self.logging_service.find_history_entry(execution_id)
self.assertIsNotNone(entry)
def test_single_dynamic_image(self):
path = test_utils.create_file('test.png')
config = create_config_model('my_script', output_files=[inline_image('##any_path.png#')])
execution_id = self.start_execution(config)
full_path = file_utils.normalize_path(path)
self.write_output(execution_id, '123\n' + full_path + '\n456')
self.wait_output_chunks(execution_id, chunks_count=1)
self.assert_images(full_path)
def test_parameter_multiselect_when_multiple_list_and_custom_separator(
self):
parameter = create_script_param_config('p1',
type='multiselect',
multiselect_separator='; ')
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 test_single_static_image(self):
path = test_utils.create_file('test.png')
config = create_config_model('my_script', output_files=[inline_image(path)])
execution_id = self.start_execution(config)
self.write_output(execution_id, '123\n456')
self.wait_output_chunks(execution_id, chunks_count=1)
self.assert_images(path)
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')
config = create_config_model('config_x',
config={'script_path': 'ls'},
parameters=[p1, p2])
executor = ScriptExecutor(config, {'p1': 'value', 'p2': 'value'})
secure_command = executor.get_secure_command()
self.assertEqual('ls -p1 ****** -p2 value', secure_command)
def test_start_logging_on_execution_start(self):
execution_id = self.executor_service.start_script(
create_config_model('my_script'),
{},
'userX',
create_audit_names(ip='localhost'))
executor = self.executor_service.get_active_executor(execution_id)
executor.process_wrapper.finish(0)
entry = self.logging_service.find_history_entry(execution_id)
self.assertIsNotNone(entry)
def test_parameter_noparam_multiselect_when_multiple_list_as_multiarg_without_space(
self):
parameter = create_script_param_config('p1',
type=PARAM_TYPE_MULTISELECT,
multiple_arguments=True,
repeat_param=False)
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 test_single_dynamic_image_when_unnormalized(self):
test_utils.create_file('sub/test.png')
config = create_config_model('my_script', output_files=[inline_image('#([\.\w]+/)+\w+.png#')])
execution_id = self.start_execution(config)
unnormalized_path = os.path.join(test_utils.temp_folder, '.', 'sub', '..', 'sub', 'test.png')
self.write_output(execution_id, '_ ' + unnormalized_path + ' _\n')
self.wait_output_chunks(execution_id, chunks_count=1)
image_keys = [img[0] for img in self.images]
self.assertEqual([unnormalized_path], image_keys)
def test_parameter_secure_multiselect(self):
parameter = create_script_param_config('p1',
param='-p1',
secure=True,
type=PARAM_TYPE_MULTISELECT)
config = create_config_model('config_x',
config={'script_path': 'ls'},
parameters=[parameter])
executor = ScriptExecutor(config, {'p1': ['one', 'two', 'three']})
secure_command = executor.get_secure_command()
self.assertEqual('ls -p1 ******', secure_command)
def test_parameter_secure_multiselect_as_multiarg(self):
parameter = create_script_param_config('p1',
param='-p1',
secure=True,
type='multiselect',
multiple_arguments=True)
config = create_config_model('config_x',
config={'script_path': 'ls'},
parameters=[parameter])
executor = ScriptExecutor(config, {'p1': ['one', 'two', 'three']})
secure_command = executor.get_secure_command()
self.assertEqual('ls -p1 ****** ****** ******', secure_command)
def test_parameter_multiselect_when_multiple_list_as_multiarg_repeat_param(
self):
parameter = create_script_param_config(
'p1',
param='-p1',
type=PARAM_TYPE_MULTISELECT,
multiselect_argument_type='repeat_param_value')
config = create_config_model('config_x', parameters=[parameter])
args_list = self.build_command_args(
{'p1': ['val1', 'val2', 'hello world']}, config)
self.assertEqual(['-p1', 'val1', '-p1', 'val2', '-p1', 'hello world'],
args_list)
def test_parameter_multiselect_when_multiple_list_and_argument_per_value_without_space(
self):
parameter = create_script_param_config(
'p1',
param='--p1=',
type=PARAM_TYPE_MULTISELECT,
multiselect_argument_type='argument_per_value',
same_arg_param=True)
config = create_config_model('config_x', parameters=[parameter])
args_list = self.build_command_args(
{'p1': ['val1', 'val2', 'hello world']}, config)
self.assertEqual(['--p1=val1', 'val2', 'hello world'], args_list)
def test_multiple_static_images(self):
path1 = test_utils.create_file('test1.png')
path2 = test_utils.create_file('test2.png')
path3 = test_utils.create_file('test3.png')
config = create_config_model('my_script',
output_files=[inline_image(path1), inline_image(path2), inline_image(path3)])
execution_id = self.start_execution(config)
self.write_output(execution_id, '123\n' + '456')
self.wait_output_chunks(execution_id, chunks_count=1)
self.assert_images(path1, path2, path3)
def test_get_user_parameter_values(self):
parameter_values = {'x': 1, 'y': '2', 'z': 'True'}
execution_service = self.create_execution_service()
parameters = test_utils.create_simple_parameter_configs(list(parameter_values.keys()) + ['const'])
parameters['const']['constant'] = True
parameters['const']['default'] = 'abc'
parameters['z']['no_value'] = True
config_model = test_utils.create_config_model(
'test_get_user_parameter_values',
username=DEFAULT_USER,
parameters=parameters.values())
execution_id = self._start_with_config(execution_service, config_model, parameter_values)
self.assertEqual(parameter_values, execution_service.get_user_parameter_values(execution_id))
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_image_path_split_in_chunks(self):
path = test_utils.create_file('test123.png')
config = create_config_model('my_script', output_files=[inline_image('##any_path.png#')])
execution_id = self.start_execution(config)
normalized = normalize_path(path)
self.write_output(execution_id, normalized[:4])
self.wait_output_chunks(execution_id, chunks_count=1)
self.write_output(execution_id, normalized[4:] + '\n')
self.wait_output_chunks(execution_id, chunks_count=2)
self.assert_images(path)
def test_find_multiple_images_by_same_pattern(self):
path1 = test_utils.create_file('test123.png')
test_utils.create_file('images/test.png')
path3 = test_utils.create_file('a.b.c.png')
path4 = test_utils.create_file('some/sub/folder/test456.png')
config = create_config_model(
'my_script', output_files=[inline_image('##any_path.png#')])
execution_id = self.start_execution(config)
paths = [normalize_path(p) for p in (path1, path3, path4)]
for index, path in enumerate(paths):
self.write_output(execution_id, '__ ' + path + ' __\n')
self.wait_output_chunks(execution_id, chunks_count=index + 1)
self.assert_images(*paths)
def test_exit_code(self):
config_model = create_config_model(
'my_script', script_command='ls', parameters=[])
execution_id = self.executor_service.start_script(
config_model,
{},
'userX',
create_audit_names(ip='localhost'))
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(14)
wait_observable_close_notification(executor.get_anonymized_output_stream(), 2)
entry = self.logging_service.find_history_entry(execution_id)
self.assertEqual(14, entry.exit_code)
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 get_config(self, execution_id):
if execution_id in self.execution_infos:
return create_config_model(self.execution_infos[execution_id].script_name)
return None
def get_secure_command(self, parameters, values):
config = create_config_model('config_x', parameters=parameters)
executor = ScriptExecutor(config, values)
return executor.get_secure_command()
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 _create_config(parameters=None):
return create_config_model('config_x', parameters=parameters)
def test_no_parameters_some_values(self):
config = create_config_model('config_x')
args_string = self.build_command_args({'p1': 'value', 'p2': 'value'}, config)
self.assertEqual([], args_string)
