def write_curr_test(params,
test,
name,
current_test_path,
addit_strings_head='',
addit_strings_tail=''):
'''
params - словарь параметров
test - список, содержание теста
name - имя теста
current_test_path - текущая директория + имя теста
addit_strings_head - имя файла с тестом, тест прикрепляющийся к началу основного теста, если нужно
addit_strings_tail - имя файла с тестом, тест прикрепляющийся к концу основного теста, если нужно
*
записывает текущий тест в файл
'''
test_path = params['TESTS_ON_RUNNER']
write_string_file(current_test_path, 'w', '')
if addit_strings_head != '':
write_string_file(current_test_path, 'w',
head_tail_test('head', params, name))
if addit_strings_head != 'only_start':
list_addit_stings = open_file_r(test_path + '\\' +
addit_strings_head + '.txt')
write_list_file(list_addit_stings, current_test_path, 'a')
write_list_file(test, current_test_path, 'a')
if addit_strings_tail != '':
list_addit_stings = open_file_r(test_path + '\\' + addit_strings_tail +
'.txt')
write_list_file(list_addit_stings, current_test_path, 'a')
write_string_file(current_test_path, 'a',
head_tail_test('tail', params, name))
def test(params, test_name):
'''
params - словарь параметров
test_name - имя запускаемого теста
*
запускает тест по названию
*
'''
print('----------------------------------------------- \n')
print(test_name)
user = findall('%(.*).feature', test_name)
cd_path = findall('!CD(.*)CD!', test_name)
addit_strings_head = findall('!ADDH(.*)ADDH!', test_name)
addit_strings_tail = findall('!ADDT(.*)ADDT!', test_name)
if len(user) != 0 and len(cd_path) != 0:
user = user[0]
cd_path = cd_path[0]
addit_strings_head = addit_strings_head[0]
addit_strings_tail = addit_strings_tail[0]
print('USER : '******'PATH : ' + cd_path)
print('HEAD : ' + addit_strings_head)
print('TAIL : ' + addit_strings_tail)
print('----------------------------------------------- \n')
params['MODEL_USER'] = user
OUT_CD = params['FINAL_LOG'] + 'OUT_CD'
print('СOPY .CD file ...')
copyfile(params['MODEL_ON_RUNNER'] + cd_path + '\\1Cv8.1CD',
OUT_CD + '\\1Cv8.1CD')
print('COPY: ' + params['MODEL_ON_RUNNER'] + cd_path + ' ---> ' +
OUT_CD)
params['WORK_PATH_BASE_CURR'] = OUT_CD
params['TESTS_ON_RUNNER'] = params['FINAL_LOG'] + 'TESTS_WITH_ERROR\\'
params['ESC_VANESSA'] = 'Ложь'
params['ESC_TEST_CLIENT'] = 'Ложь'
test_lst = open_file_r(params['TESTS_ON_RUNNER'] + test_name)
curr_test = []
flag = False
for i in test_lst:
if i.find('!$') != -1:
flag = True
if flag == True:
curr_test.append(i)
write_curr_test(params, curr_test, 'out',
params['TESTS_ON_RUNNER'] + 'out.feature',
addit_strings_head, addit_strings_tail)
start_vanessa(params, 'out.feature')
print('----------------------------------------------- \n')
else:
print('ERROR: USER OR PATH')
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 write_curr_test(params,
test,
name_list,
current_test_path,
addit_strings_head='',
addit_strings_tail=''):
'''
params - словарь параметров
test - список, содержание теста
name_list - имя теста и имя пользователя
current_test_path - текущая директория + имя теста
addit_strings_head - имя файла с тестом, тест прикрепляющийся к началу основного теста, если нужно
addit_strings_tail - имя файла с тестом, тест прикрепляющийся к концу основного теста, если нужно
*
записывает текущий тест в файл
'''
test_path = params['TESTS_ON_RUNNER']
#записали пустую строку создав файл
write_string_file(current_test_path, 'w', '')
if addit_strings_head != '':
#записали "шаг" с запуском эталона
write_string_file(current_test_path, 'w',
head_tail_test('head', params, name_list))
if addit_strings_head != 'only_start':
#если перед тестом есть еще "шаги", получили и записали их
list_addit_stings = open_file_r(test_path + '\\' +
addit_strings_head + '.txt')
write_list_file(list_addit_stings, current_test_path, 'a')
#записали сам тест
write_list_file(test, current_test_path, 'a')
if addit_strings_tail != '':
#получили и записали, если что то нужно добавить в хвост
list_addit_stings = open_file_r(test_path + '\\' + addit_strings_tail +
'.txt')
write_list_file(list_addit_stings, current_test_path, 'a')
def parse_log_path(params):
'''
params - словарь параметров
*
парсит лог файлы каждого теста
берет от каждого лога название и его последние 6 строк если в нем были ошибки
*
return [list_for_tests_with_error, list_for_final_data] - возвращает список из списка ошибочных тестов
и списка строк финального лога
'''
list_for_final_data = []
list_for_tests_with_error = []
list_for_current_log = []
curr_final_list = []
log_path = params['WORK_PATH'] + 'log\\'
doc_list = listdir(log_path)
error_flag = False
for i in doc_list:
if i.find('_LOG') != -1:
log_list = open_file_r(log_path + i, 'windows-1251')
for x in log_list:
time_list = findall(r'\d{2}.\d{2}.\d{4}', x)
if len(time_list) > 0:
list_for_current_log.append(x)
if x.find("БЫЛИ ОШИБКИ") != -1:
error_flag = True
if error_flag == True:
curr_final_list.append(
'----------------------------------------------- \n')
curr_final_list.append('\t' + i + ' : \n')
curr_final_list.append(' *** \n')
for z in list_for_current_log:
if z.find("ОписаниеОшибки") != -1:
curr_final_list.append(z)
break
curr_final_list.append(
'----------------------------------------------- \n')
list_for_final_data.append(curr_final_list.copy())
list_for_tests_with_error.append(i)
error_flag = False
list_for_current_log.clear()
curr_final_list.clear()
return [list_for_tests_with_error, list_for_final_data]
def prepare_tests(params,
test_name,
addit_strings_head='',
addit_strings_tail=''):
'''
params - словарь параметров
test_name - имя общего теста
addit_strings_head - имя файла с тестом, тест прикрепляющийся к началу основного теста, если нужно
addit_strings_tail - имя файла с тестом, тест прикрепляющийся к концу основного теста, если нужно
*
"режет" общий файл с тестом на N количество основных тестов для запуска
прикрепляет к ним "голову" и "конец" если нужно
'''
test_path = params['TESTS_ON_RUNNER']
USER = params['MODEL_USER']
test_list = open_file_r(test_path + '\\' + test_name)
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':
if name.find("%") != -1:
parse_name(params, name)
current_test_path = test_path + '\\' + '@_' + name + '.feature'
else:
continue
else:
current_test_path = test_path + '\\' + '@_' + name + '%' + params[
'MODEL_USER'] + '.feature'
print(current_test_path)
write_curr_test(params, test, name, current_test_path,
addit_strings_head, addit_strings_tail)
print('----------------------------------------------- \n')
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
