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_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_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_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_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))