def start_vanessa(param_dict, test_name, kill=True, global_test_name=''):
'''
param_dict - словарь параметров
test_name - имя теста, присваивается автоматически в зависимости от тэгов расставленых в фича-файле
например: "@_$Наценка-сумма-строка"
kill -
*
подготавливает конфиг для Ванессы
запускает Ванессу с нужным тестом
создает лог запуска теста
'''
VAParams = va_params(param_dict, test_name)
path_VAParams = param_dict['TESTS_ON_RUNNER'] + 'VAParams.json'
path_VAParams = path_VAParams.replace('\\', '\\\\')
write_string_file(path_VAParams, 'w', VAParams)
comm_str = '{PLATFORM} ENTERPRISE /F {PATH_BASE} /DEBUG /AllowExecuteScheduledJobs -Off /DisableStartupDialogs /DisableStartupMessages /N"Администратор" /P"" /Execute {VANNESSA_EPF} /TESTMANAGER /C"StartFeaturePlayer;VBParams={VANESSA_PARAMS}" /Out {LOG_PATH}'.format(
PLATFORM=param_dict['START_PL_1C'],
PATH_BASE=param_dict['WORK_PATH_BASE_M'],
VANNESSA_EPF=param_dict['VANNESSA_EPF'],
VANESSA_PARAMS=path_VAParams,
LOG_PATH=param_dict['LOG_PATH'])
result = just_do_it(comm_str, param_dict, '1cv8.exe', 'CALL VANESSA', kill,
param_dict['CLIENT'])
if param_dict['FLAG_ERROR_START'] == False:
log_name = '{0}\\log_{1}\\LOG_{2}({3}).txt'.format(
param_dict['REPORTS_PATH'], param_dict['CONF'], test_name,
global_test_name)
log_save('CREATE LOG: ' + log_name + '\n', param_dict)
copyfile(param_dict['LOG_PATH'], log_name)
return result
def just_do_it(command, param_dict, about='', p_1c='', client=None):
'''
command - консольная команда
about - строка описыват что делаем
p_1c=''
*
запускает консольную команду в процессе
'''
log_save(about + ' : ' + command, param_dict)
proc(command, p_1c, False, client)
def del_path(cur_path, params):
'''
cur_path - директория которую нужно удалить
*
удаляет директорию
'''
if path.exists(cur_path):
log_save('DEL ' + cur_path, params)
rmtree(cur_path)
else:
log_save('NOT DEL ' + cur_path, params)
def prepare_tests(params,
test_name,
addit_strings_head='',
addit_strings_tail='',
SWAP_CURR_STR=[],
DT=''):
'''
params - словарь параметров
test_name - имя общего теста
addit_strings_head - имя файла с тестом, тест прикрепляющийся к началу основного теста, если нужно
addit_strings_tail - имя файла с тестом, тест прикрепляющийся к концу основного теста, если нужно
*
"режет" общий файл с тестом на N количество основных тестов для запуска
прикрепляет к ним "голову" и "конец" если нужно
'''
test_path = params['TESTS_ON_RUNNER']
USER = params['MODEL_USER']
TEST_USER_LIST = params['TEST_USER_LIST']
TEST_USER_LIST_append = TEST_USER_LIST.append
test_list = open_file_r(test_path + '\\' + test_name)
test_list = hot_swap(test_list, SWAP_CURR_STR,
params['WORK_PATH_BASE_CURR'])
all_tests = parse_dirty_test(test_list)
for test in all_tests:
if len(test) == 0:
continue
#извлекает имя пользователя из первой строки теста
name_list = split('[$\n]', test[0])
name = name_list[1]
if USER == 'take_from_testname' or name.find("%") != -1:
usr_list = split(r'[%.]', name)
if len(usr_list) < 2:
usr_name = ''
else:
usr_name = usr_list[1]
curr_test_name = [name, usr_name, False, False, DT]
else:
curr_test_name = [name, USER, False, False, DT]
#формирует имя файла с тестом
current_test_path = '{0}\\@_{1}.feature'.format(test_path, name)
log_save('директория текущего теста: ' + current_test_path + '\n',
params)
TEST_USER_LIST_append(curr_test_name)
params['TEST_USER_LIST'] = TEST_USER_LIST
write_curr_test(params, test, curr_test_name, current_test_path,
addit_strings_head, addit_strings_tail)
def just_do_it(command,
param_dict,
wait_1c='',
about='',
kill=False,
client=None):
'''
command - консольная команда
wait_1c - имя процесса 1с, если нужно ждать 1с
about - строка описыват что делаем
kill - если нужно убить процесс
*
запускает консольную команду в процессе
'''
log_save(about + ' : ' + command, param_dict)
if param_dict['FLAG_ERROR_START'] == False:
result = proc(command, wait_1c, kill, client)
else:
result = proc(command)
return result
def update_test(params, usr='******'):
'''
params - словарь параметров
usr - подставлять запуск от администратора или пользователя
*
собирает содержание файла с тестом: "Тест обновления программы"
нужен для обновления эталонной базы
*
return test - возвращает строку с содержанием файла
'''
if usr == 'adm':
user = params['MODEL_ADMIN_USER']
elif usr == 'usr':
user = params['MODEL_USER']
else:
user = ''
test = '''#language: ru
@tree
Функциональность: Тест обновления программы
Контекст:
\tИ Я закрыл все окна клиентского приложения
@КодСценария=000000001
Сценарий: Тест обновления программы
\tКогда Я подключаю клиент тестирования с параметрами:
\t\t| \'Имя\' | \'Синоним\' | \'Порт\' | \'Строка соединения\' | \'Логин\' | \'Пароль\' | \'Запускаемая обработка\' | \'Дополнительные параметры строки запуска\' |
\t\t| \'test\' | \'\' | \'\' | \'File="''' + params[
'WORK_PATH_BASE_CURR'] + '''";\' | \'''' + user + '''\' | \'\' | \'\' | \'\'|
\tКогда открылось окно \'Легальность получения обновлений\'
\tИ я изменяю флаг \'Я подтверждаю легальность получения обновления в соответствии с вышеизложенными условиями\'
\tИ я нажимаю на кнопку \'Продолжить\'
\tИ я жду открытия окна "Что нового в конфигурации Розница, редакция 2.3" в течение 600 секунд
'''
log_save(test + '\n', params)
return test
def prepare_st(param_dict):
'''
param_dict - словарь параметров
*
устанавливает кодировку в консоли для русских символов
подключается к указанным компьютерам
копирует платформу на компьютер где будет прохолить тест
копирует Ванессу на компьютер где будет прохолить тест
копирует тесты, конфигурацию и эталоны на компьютер где будет прохолить тест
создает директорию для логфайлов
'''
client = param_dict['CLIENT']
NET_USER = param_dict['NET_USER']
NET_DOMAIN = param_dict['NET_DOMAIN']
NET_PASSWORD = param_dict['NET_PASSWORD']
TESTS_ON_RUNNER = param_dict['TESTS_ON_RUNNER']
WORK_PATH = param_dict['WORK_PATH']
TEST_CATALOG = param_dict['TEST_CATALOG']
PREPARE_MODE = param_dict['PREPARE_MODE']
REPORTS_PATH = param_dict['REPORTS_PATH']
MODEL_ON_RUNNER = param_dict['MODEL_ON_RUNNER']
if not path.exists(TEST_CATALOG):
log_save('CREATE : ' + TEST_CATALOG, param_dict)
mkdir(TEST_CATALOG)
xcopy_template = 'XCOPY \"{0}\" \"{1}\" /H /Y /C /R /S /J /Q'
copy_from_test_repo = 'XCOPY \"{0}\\tests_git\" \"{1}\" /H /Y /C /R /S /J /Q'.format(
REPORTS_PATH, TESTS_ON_RUNNER)
copy_from_tests = xcopy_template.format(param_dict['TESTS_PATH'],
TESTS_ON_RUNNER)
if PREPARE_MODE == 'uprep+ret':
#удаляем все эталонные базы
path_list = listdir(MODEL_ON_RUNNER)
for i in path_list:
curr_path = MODEL_ON_RUNNER + i
if path.isdir(curr_path):
del_path(curr_path, param_dict)
#или скачиваем все исходники
else:
if NET_DOMAIN != '':
just_do_it('net use', param_dict, 'NET')
just_do_it('net use /delete * /y', param_dict, 'NET')
net_con_1 = 'net use {0} /PERSISTENT:NO /User:{1}\\{2} {3}'.format(
param_dict['BUILD_FILES_Trunk'], NET_DOMAIN, NET_USER,
NET_PASSWORD)
just_do_it(net_con_1, param_dict, 'NET CON')
just_do_it('net use', param_dict, 'NET')
copy_platform = xcopy_template.format(
param_dict['PLATFORM_PATH'], param_dict['PLATFORM_PATH_ON_RUNNER'])
copy_vanessa = xcopy_template.format(param_dict['VANESSA_PATH'],
param_dict['VANESSA_ON_RUNNER'])
copy_vanessa_tools = xcopy_template.format(
param_dict['VANESSA_TOOLS'], param_dict['VANESSA_TOOLS_ON_RUNNER'])
copy_all_dt = xcopy_template.format(param_dict['MODEL_PATH'],
param_dict['MODEL_ON_RUNNER'])
copy_cf = xcopy_template.format(param_dict['CF_PATH'], WORK_PATH)
command_list = [
[just_do_it, [copy_platform, param_dict, 'COPY PLATFORM']],
[just_do_it, [copy_vanessa, param_dict, 'COPY VANESSA']],
[
just_do_it,
[copy_vanessa_tools, param_dict, 'COPY VANESSA TOOLS']
], [just_do_it, [copy_all_dt, param_dict, 'COPY ALL DT']],
[just_do_it, [copy_cf, param_dict, 'COPY CF']]
]
proc_list = []
proc_list_append = proc_list.append
for list_i in command_list:
if list_i[1][1] == 'COPY CF':
if PREPARE_MODE == 'cpcf':
proc_list_append(dif_proc(list_i[0], list_i[1]))
else:
if not path.exists(WORK_PATH):
mkdir(WORK_PATH)
else:
proc_list_append(dif_proc(list_i[0], list_i[1]))
sleep(1)
for proc in proc_list:
proc.join()
#создание каталога с отчетами
if not path.exists(REPORTS_PATH):
log_save('CREATE : ' + REPORTS_PATH, param_dict)
mkdir(REPORTS_PATH)
log_dir = '{0}\\log_{1}'.format(REPORTS_PATH, param_dict['CONF'])
if not path.exists(log_dir):
log_save('CREATE : ' + log_dir, param_dict)
mkdir(log_dir)
#копирование автотестов
if param_dict['GIT_REPO_TESTS'] != '':
if path.exists(REPORTS_PATH + '\\tests_git'):
just_do_it(
'cd "' + REPORTS_PATH +
'\\tests_git" & git pull origin master > cmd', param_dict,
'GIT PULL')
else:
just_do_it('cd ' + REPORTS_PATH + ' & git clone "' +\
param_dict['GIT_REPO_TESTS'] + '" "tests_git" > cmd', param_dict, 'GIT CLONE')
just_do_it(copy_from_test_repo, param_dict, 'COPY FROM TEST REPO')
else:
just_do_it(copy_from_tests, param_dict, 'COPY TESTS')
def main_func(sys_argv_list):
'''
MaiN
получает лист со сценарием тестирования
получает словарь с параметрами
очищает тестовый каталог
выполняет сценарии
'''
#proc('chcp 65001') #устанавливает кодировки в UTF для консоли
proc('set PYTHONIOENCODING=utf-8')
#proc('chcp 1251')
#proc('set PYTHONIOENCODING=windows-1251')
#print_cat()
kill_1C()
#получает все настройки и сценарий тестов
params = ret_param_dict(sys_argv_list)
scenario_list = params['SCEN']
kill_python(params)
#запускает отдельный процесс, следящий за выполнением консольных команд
WORK_PATH = params['WORK_PATH']
servo = start_servo(WORK_PATH, params['REPORTS_PATH'])
log_save('SERVO PID : ' + str(servo.pid), params)
client = start_client(servo)
params['START_TIME'] = str(datetime.now())
params['CLIENT'] = client
#обходит каждый тест из сценария и выполняет его--------------------------------------------
for test in scenario_list:
#подготовка к запуску теста
DT = test['DT']
params['MODEL_ON_RUNNER_CURRENT_DT'] = params['MODEL_ON_RUNNER'] + DT
params['MODEL_ADMIN_USER'] = test['ADM_USER']
params['MODEL_USER'] = test['USER']
params['PREPARE_MODE'] = test['PREPARE_MODE']
flag_curr_path_cd = env_prepare(params, DT)
TEST_FILE = test['TEST_FILE']
ADD_HEAD = test['ADD_HEAD']
ADD_TAIL = test['ADD_TAIL']
ADDR = test["ADDR"]
SWAP_CURR_STR = test["SWAP_CURR_STR"]
#запуск тестов
start_tests(params, TEST_FILE, ADD_HEAD, ADD_TAIL, flag_curr_path_cd,
SWAP_CURR_STR, DT)
#-------------------------------------------------------------------------------------------
params['END_TIME'] = str(datetime.now())
if len(sys_argv_list) <= 1:
#запускает консольное меню с упавшими тестами, что бы воспроизвести их вновь----------------
TEST_USER_LIST = params['TEST_USER_LIST']
list_error_tests = []
count = 0
for i in TEST_USER_LIST:
if i[3] == True:
count = count + 1
list_error_tests.append([str(count), i])
flag_job_with_error_tests = True
MODEL_ON_RUNNER = params['MODEL_ON_RUNNER']
while flag_job_with_error_tests:
#print_cat()
print('start: {0}, end: {1}.'.format(params['START_TIME'],
params['END_TIME']))
for i in list_error_tests:
print('{0}) {1}'.format(i[0], i[1][0]))
print(
"\n$ введи номер теста для запуска,\n$ для выхода нажми \"0\",\n$ для отправки почты набери \"send\""
)
num = input('---------------------------> :')
if num == '0':
flag = False
break
elif num == 'send':
#почтовая рассылка
CONF_CURR = params["CONF"]
err_list = open_file_r(WORK_PATH + 'log_spent_tests.txt')
error_str = ''
for i in err_list:
error_str = error_str + ''.join(i)
for i in scenario_list:
ADDR = i['ADDR']
if ADDR != '':
try:
send_mail(
dict(CONF=CONF_CURR, ADDR=ADDR,
TEXT=error_str))
except:
log_save('ERROR send mail', params)
else:
for i in list_error_tests:
if i[0] == num:
test_name = i[1][0]
flag_curr_path_cd = MODEL_ON_RUNNER + '\\' + 'storage_' + i[
1][4]
push_cd_client(params, flag_curr_path_cd)
params['FLAG_ERROR_START'] = True
params['ESC_VANESSA'] = 'Ложь'
params['ESC_TEST_CLIENT'] = 'Ложь'
start_vanessa(params, '@_' + test_name + '.feature',
False, test_name)
#-------------------------------------------------------------------------------------------
end(client, servo)
kill_python(params)
def ret_param_dict(sys_argv_list):
'''
'''
current_directory = path.abspath(__file__)
current_directory = path.split(current_directory)[0]
#очистка логов
#log = current_directory + '\\main_log.log'
#if path.isfile(log):
#remove(log)
current_directory = path.split(current_directory)[0]
#запуск с параметрами или без
len_argv_list = len(sys_argv_list)
if len_argv_list == 4:
config = sys_argv_list[1]
scen = sys_argv_list[2]
ver_conf = sys_argv_list[3]
if len(ver_conf) >= 50:
print('нельзя вводить больше 50 знаков\n')
exit()
elif len_argv_list < 4 and len_argv_list > 1 or len_argv_list > 4:
print('неправильное количество параметров в команде\n')
exit()
else:
configs_list = []
scen_list = []
dir_list = listdir(current_directory)
for i in dir_list:
if i.find('config_') != -1:
configs_list.append(i)
elif i.find('scen_') != -1:
scen_list.append(i)
#консольное меню------------------------------------------------------------------------------------------------------------
config = menu_cicle('\nВыбери номер конфигурационного файла: \n',
configs_list)
scen = menu_cicle('\nВыбери номер файла со сценарием: \n', scen_list)
ver_conf = input('\nВведи имя текущего прогона: ')
if len(ver_conf) >= 50:
print('нельзя вводить больше 50 знаков\n')
exit()
#---------------------------------------------------------------------------------------------------------------------------
#читаем файлы с настройками
config = open_file_r(current_directory + '\\' + config)
scen = open_file_r(current_directory + '\\' + scen)
#кортежи для проверки обязательности заполнения настройки, если True то настройка обязательна
config_params_names = (
('PREPARE_MODE', True),
('BUILD_FILES', True),
('PLATFORM_NUMBER', True),
('PLATFORM_PATH', True),
('STARTER_1C', True),
('NET_DOMAIN', False),
('NET_USER', False),
('NET_PASSWORD', False),
('REPO_PATH', False),
('REPO_VER', False),
('REPO_USER', False),
('REPO_PASSWORD', False),
('GIT_REPO_TESTS', False),
('REPORTS', False),
)
scen_params_names = (
('ЭТАЛОН', 'DT', True),
('ПОЛЬЗОВАТЕЛЬ С ПОЛНЫМИ ПРАВАМИ', 'ADM_USER', True),
('ПОЛЬЗОВАТЕЛЬ ДЛЯ ТЕСТА', 'USER', True),
('ФАЙЛ С ТЕСТОМ', 'TEST_FILE', True),
('ПРИКРЕПИТЬ ДОП. ТЕСТ В НАЧАЛО', 'ADD_HEAD', False),
('ПРИКРЕПИТЬ ДОП. ТЕСТ В КОНЕЦ', 'ADD_TAIL', False),
('ПОЧТА', 'ADDR', False),
('ЗАМЕНА СТРОКИ', 'SWAP_CURR_STR', False),
)
#пустые словари для первоначальных настроек
first_params = dict(PREPARE_MODE='',
BUILD_FILES='',
PLATFORM_NUMBER='',
PLATFORM_PATH='',
STARTER_1C='',
NET_DOMAIN='',
NET_USER='',
NET_PASSWORD='',
REPO_PATH='',
REPO_VER='',
REPO_USER='',
REPO_PASSWORD='',
GIT_REPO_TESTS='',
REPORTS='')
one_test_params = dict(PREPARE_MODE='',
DT='',
ADM_USER='',
USER='',
TEST_FILE='',
ADD_HEAD='',
ADD_TAIL='',
ADDR='',
SWAP_CURR_STR=[])
#заполнение первоначальных настроек из считанных файлов---------------------------------------------------------------------
#заполнение настроек
scenario_list = []
for param_tuple in config_params_names:
for i_str in config:
param = param_tuple[0]
control_str = i_str[0:3]
if control_str.find('#') == -1 and i_str.find(param) != -1:
val = i_str.split('=')[1]
val = val.strip('\n')
val = val.strip(' ')
if val == '' and param_tuple[1]:
print(
'\nне заполнен обязательный параметр {0}\nзавершение работы\n'
.format(param))
exit()
first_params[param] = val
break
#заполнение настроек сценариев
test_counter = 1
for i_str in scen:
control_str = i_str[0:3]
if control_str.find('#') == -1 and i_str.find('ЭТАЛОН') != -1:
if one_test_params['TEST_FILE'] != '':
# когда второй раз находит слово ЭТАЛОН.
# то в настройки первого теста добавляет PREPARE_MODE, в остальных будет ret
if test_counter == 2:
one_test_params['PREPARE_MODE'] = first_params[
'PREPARE_MODE']
else:
one_test_params['PREPARE_MODE'] = 'ret'
test_counter = test_counter + 1
scenario_list.append(one_test_params.copy())
for i in one_test_params:
one_test_params[i] = ''
val = i_str.split('=')[1]
val = val.strip('\n')
val = val.strip(' ')
if val == '':
print(
'\nне заполнен обязательный параметр ЭТАЛОН\nзавершение работы\n'
)
exit()
one_test_params['DT'] = val
test_counter = test_counter + 1
elif control_str.find('#') == -1:
for param_tuple in scen_params_names:
param = param_tuple[0]
name_param = param_tuple[1]
if i_str.find(param) != -1:
val = i_str.split('=')[1]
val = val.strip('\n')
val = val.strip(' ')
if val == '' and param_tuple[2]:
print(
'\nне заполнен обязательный параметр {0}\nзавершение работы\n'
.format(param))
exit()
if param == 'ЗАМЕНА СТРОКИ':
val_list = val.split(',')
cr_ls = []
final_swap_list = []
for i in val_list:
i = i.strip(' ')
cr_ls.append(i)
if len(cr_ls) == 2:
final_swap_list.append(cr_ls.copy())
cr_ls = []
one_test_params[name_param] = final_swap_list
else:
one_test_params[name_param] = val
break
if one_test_params['TEST_FILE'] != '':
if test_counter == 2: # если тест всего один то значение счетчика должно быть 2
one_test_params['PREPARE_MODE'] = first_params['PREPARE_MODE']
else:
one_test_params['PREPARE_MODE'] = 'ret'
scenario_list.append(one_test_params.copy())
#---------------------------------------------------------------------------------------------------------------------------
if first_params['REPORTS'] == '':
first_params['REPORTS'] = current_directory + '\\REPORTS'
pid_curr_proc = str(getpid())
platform_number = first_params['PLATFORM_NUMBER']
platform = first_params['PLATFORM_PATH'] + platform_number
build_files = first_params['BUILD_FILES']
storage = current_directory + '\\TEST_CATALOG'
work = storage + '\\work\\'
#финальный словарь с настройками-------------------------------------------------------------------------------------------
param_dict = dict(
CONF=ver_conf,
BUILD_FILES_Trunk=build_files,
PLATFORM_PATH=build_files + '\\platforms\\' + platform_number,
PLATFORM_PATH_ON_RUNNER=platform + '\\',
START_PL_1C='\"' + platform + '\\bin\\1cv8.exe\"',
PID=pid_curr_proc,
START_1cestart='"{0}"'.format(first_params['STARTER_1C']),
CURR_DIR=current_directory + '\\',
VANESSA_PATH=build_files + '\\vanessa\\vanessa-automation',
VANESSA_TOOLS=build_files + '\\vanessa\\vanessa-tools',
TEST_CATALOG=storage,
VANESSA_ON_RUNNER=storage + '\\vanessa\\vanessa-automation\\',
VANESSA_TOOLS_ON_RUNNER=storage + '\\vanessa\\vanessa-tools\\',
VANNESSA_EPF=storage +
'\\vanessa\\vanessa-automation\\vanessa-automation.epf',
TESTS_PATH=build_files + '\\tests',
TESTS_ON_RUNNER=storage + '\\tests\\',
MODEL_PATH=build_files + '\\model',
MODEL_ON_RUNNER=storage + '\\model\\',
MODEL_ON_RUNNER_CURRENT_DT='',
WORK_PATH=work,
WORK_PATH_BASE_M=work + 'base_M',
WORK_PATH_BASE_C=work + 'base_C',
WORK_PATH_BASE_CURR='',
CF_PATH=build_files + '\\cf',
LOG_PATH=work + 'log.txt',
MODEL_ADMIN_USER='',
MODEL_USER='',
NET_DOMAIN=first_params['NET_DOMAIN'],
NET_USER=first_params['NET_USER'],
NET_PASSWORD=first_params['NET_PASSWORD'],
REPO_PATH=first_params['REPO_PATH'],
REPO_VER=first_params['REPO_VER'],
REPO_USER=first_params['REPO_USER'],
REPO_PASSWORD=first_params['REPO_PASSWORD'],
GIT_REPO_TESTS=first_params['GIT_REPO_TESTS'],
ESC_VANESSA='Истина',
ESC_TEST_CLIENT='Истина',
STORAGE_CURR_1CD='',
# замеры времени начала и окончания прогона
START_TIME='',
END_TIME='',
PREPARE_MODE='',
# хранит объект "клиент" с подключением к порту
CLIENT=None,
# хранит имя теста и имя пользователя от него
# [0] - имя теста, [1] - имя ползователя, [2] - False если тест еще не использовался,
# [3] - False если ошибок не было, [4] - имя использующегося DT файла (оно же имя папки с чистой базой под тест)
TEST_USER_LIST=[],
#если истина то запуск происходит без контроля завершения и не пишутся логи (для воспроизведения упавших тестов)
FLAG_ERROR_START=False,
REPORTS_PATH=first_params['REPORTS'],
SCEN=scenario_list)
#--------------------------------------------------------------------------------------------------------------------------
log_save('текущая директория: ' + current_directory, param_dict)
log_save('MAIN PID : ' + pid_curr_proc, param_dict)
return param_dict
def va_params(param_dict, test_name):
'''
param_dict - словарь параметров
test_name - имя теста, присваивается автоматически в зависимости от тэгов расставленых в фича-файле
*
собирает содержание json файла с настройками запуска теста для Ванессы
нужно изменять крайне внимательно
*
return params - возвращает строку с содержанием файла
'''
TESTS_ON_RUNNER = param_dict['TESTS_ON_RUNNER']
feature_path = TESTS_ON_RUNNER + test_name
if test_name.find("@_") != -1:
name = param_dict['CONF'] + '_' + split('[%.]',
split('@_', test_name)[1])[0]
else:
name = param_dict['CONF'] + '_' + test_name
feature_path = feature_path.replace('\\', '\\\\')
platform = param_dict['PLATFORM_PATH_ON_RUNNER'].replace('\\', '\\\\')
va = param_dict['VANESSA_ON_RUNNER'].replace('\\', '\\\\')
tests = TESTS_ON_RUNNER.replace('\\', '\\\\')
reports = param_dict['REPORTS_PATH'].replace('\\', '\\\\')
params = '''{
"Lang": "ru",
"DebugLog": true,
"КаталогФич": "''' + feature_path + '''",
"ДобавлятьКИмениСценарияУсловияВыгрузки": false,
"ИмяТекущейСборки": "''' + name + '''",
"ЗагрузкаФичПриОткрытии": "Загружать",
"ВерсияПлатформыДляГенерацииEPF": "''' + platform + '''\\\\bin",
"ВыполнитьСценарии": true,
"ЗавершитьРаботуСистемы": "''' + param_dict['ESC_VANESSA'] + '''",
"ЗакрытьTestClientПослеЗапускаСценариев": "''' + param_dict[
'ESC_TEST_CLIENT'] + '''",
"ВыполнениеСценариев": {
"ВыполнятьШагиАссинхронно": false,
"ИнтервалВыполненияШагаЗаданныйПользователем": 0.1,
"ОбновлятьСтатистикуВДереве": true,
"ОбновлятьДеревоПриНачалеВыполненияСценария": true,
"ОстановкаПриВозникновенииОшибки": false,
"ПоказыватьНомерСтрокиДереваПриВозникновенииОшибки": true,
"ПриравниватьPendingКFailed": false,
"ТаймаутДляАсинхронныхШагов": 0,
"КоличествоСекундПоискаОкна": 5,
"КоличествоПопытокВыполненияДействия": 3,
"БезопасноеВыполнениеШагов": true,
"ПаузаПриОткрытииОкна": 0
},
"КлиентТестирования": {
"ЗапускатьКлиентТестированияСМаксимизированнымОкном": true,
"ТаймаутЗапуска1С": 120,
"ДиапазонПортовTestclient": "48100-48200",
"ЗапускатьТестКлиентВРежимеОтладки": false,
"КлючиОтладки": "",
"АдресОтладчика": "",
"ДанныеКлиентовТестирования": [
]
},
"ДелатьОтчетВФорматеАллюр": "Истина",
"КаталогOutputAllureБазовый": "''' + reports + '''",
"СоздаватьПодкаталогВКаталогеAllureДляЭтойСборки": "Истина",
"ДелатьОтчетВФорматеjUnit": false,
"ДелатьОтчетВФорматеCucumberJson": false,
"ДелатьОтчетВФорматеСППР": false,
"СоздаватьИнструкциюHTML": false,
"СоздаватьИнструкциюMarkdown": false,
"ДелатьОтчетВоВнутреннемФормате": false,
"КаталогиБиблиотек": "''' + va + '''features\\\Libraries",
"ДелатьЛогВыполненияСценариевВЖР": true,
"ДелатьЛогВыполненияСценариевВТекстовыйФайл": false,
"ВыводитьВЛогВыполнениеШагов": false,
"ДелатьЛогОшибокВТекстовыйФайл": false,
"СобиратьДанныеОСостоянииАктивнойФормыПриОшибке": false,
"СобиратьДанныеОСостоянииВсехФормПриОшибке": false,
"ИмяФайлаЛогВыполненияСценариев": "''' + tests + test_name + '''",
"ИмяКаталогаЛогОшибок": "''' + tests + '''",
"КомандаСделатьСкриншот": "''' + '' + '''",
"ДелатьСкриншотПриВозникновенииОшибки": false,
"СниматьСкриншотКаждогоОкна1С": false,
"КаталогПроекта": "''' + tests + '''",
"СоздаватьИнструкциюВидео": false,
"ИспользоватьSikuliXСервер": false,
"ИскатьЭлементыФормыПоИмени": false,
"ДобавлятьПриНакликиванииМетаИнформацию": false,
"ТегTreeВключенПоУмолчанию": true
}
'''
log_save(params + '\n', param_dict)
return params