import unittest
from parameterized import parameterized
from common.train_track import TrainTrack
from util.service import Service
from util.utility import Utility
import time
test_config_info = Utility.get_json('..\\config\\testdata.conf')
track_info = Utility.get_excel_to_tuple(test_config_info[10])
track_info_public = Utility.get_excel_to_tuple(test_config_info[11])
track_info_student = Utility.get_excel_to_tuple(test_config_info[12])
class TraintrackTest(unittest.TestCase):
def setUp(self) -> None:
self.driver = Service.get_driver('..\\config\\base.conf')
self.track = TrainTrack(self.driver)
@parameterized.expand(track_info)
@unittest.skip
def test_track(self, keyw, cus_status, cus_pri, cus_time, cus_remark,
expect):
self.track.ts.send_keywords(keyw)
self.track.ts.click_search()
time1 = self.track.get_track_times()
self.track.do_tracking(cus_status, cus_pri, cus_time, cus_remark)
self.driver.refresh()
try:
self.track.ts.select_pooltype('个人池')
self.track.ts.send_keywords(keyw)
time.sleep(2)
import unittest
from parameterized import parameterized
from util.utility import Utility
from common.train_public import TrainPublic
from util.service import Service
test_config_data = Utility.get_json('..\\config\\testdata.conf')
test_claim_one = Utility.get_excel_to_tuple(test_config_data[16])
test_claim_all = Utility.get_excel_to_tuple(test_config_data[17])
class PublicTest(unittest.TestCase):
def setUp(self) -> None:
self.driver = Service.get_driver('..\\config\\base.conf')
self.public = TrainPublic(self.driver)
@parameterized.expand(test_claim_one)
def test_do_claim_one(self, worker, expect):
self.public.do_claim_one(worker)
message = self.public.get_result()
if '成功' in message:
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
@parameterized.expand(test_claim_all)
def test_do_claim_all(self, worker, expect):
self.public.do_claim_all(worker)
message = self.public.get_result()
if '成功' in message:
import requests, time
import unittest
from parameterized import parameterized
from common.login import Login
from util.utility import Utility
data_config_path = '../config/testdata.conf'
data_config_info = Utility.get_json(data_config_path)
login_info = Utility.get_excel_to_tuple(data_config_info[0])
class LoginTest(unittest.TestCase):
@parameterized.expand(login_info)
def test_login(self,url,method,test_data,resp_code,resp_content):
login_resp = Login().do_login(url, test_data)
login_resp_content = login_resp.text
self.assertEqual(login_resp_content,resp_content)
if __name__ == '__main__':
unittest.main(verbosity=2)
#-*- coding:utf-8 -*-
# author JTT
# @Time:2020/4/26 14:37
import requests, time
import unittest
from parameterized import parameterized
from common.student import student
from common.training import training
from util.utility import Utility
#基本信息
test_infos = Utility.get_json('..\\config\\jtttestdata.conf')
#排课测试数据
test_add_course_infos = Utility.get_excel_to_tuple(test_infos[5])
#教师课程修改测试数据
test_edit_course_infos = Utility.get_excel_to_tuple(test_infos[6])
#指定值班测试数据
test_saveDuty_infos = Utility.get_excel_to_tuple(test_infos[7])
#申请加班测试数据
test_saveApply_infos = Utility.get_excel_to_tuple(test_infos[8])
#技术面试测试数据
test_skills_interview_infos = Utility.get_excel_to_tuple(test_infos[9])
class Training(unittest.TestCase):
#排课
@parameterized.expand(test_add_course_infos)
def test_add_course(self, URL, METHOD, DATA, CODE, CONTENT, expect):
arr = [DATA['arr']]
import unittest
from parameterized import parameterized
from util.utility import Utility
data_config_path = '../config/testdata.conf'
data_config_info = Utility.get_json(data_config_path)
query_all_data = Utility.get_excel_to_tuple(data_config_info[0])
query_dev_data = Utility.get_excel_to_tuple(data_config_info[1])
add_choice_data = Utility.get_excel_data_to_tuple(data_config_info[2])
add_blank_data = Utility.get_excel_data_to_tuple(data_config_info[3])
add_answer_data = Utility.get_excel_data_to_tuple(data_config_info[4])
create_test_data = Utility.get_excel_to_tuple(data_config_info[5])
replace_test_data = Utility.get_excel_data_to_tuple(data_config_info[6])
download_test_data = Utility.get_excel_to_tuple(data_config_info[7])
class QuestionsBankTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
from common.questions_bank import QuestionsBank
cls.questons_obj = QuestionsBank()
@classmethod
def tearDownClass(cls):
pass
# 查询所有题目接口测试
@parameterized.expand(query_all_data)
def test_query_question_all(self, url, method, test_data, resp_code,
resp_content):
query_all_resp = self.questons_obj.query_all(url, test_data)
# Author: Administrator
# Date: 2020/2/10
#-------------------------------------------------------------------------------
# 该模块封装与市场营销相关的测试
import time, unittest
from parameterized import parameterized
# 获取登录用的测试信息
from common.resource_management import ManageResource
from util.service import Service
from util.utility import Utility
test_config_info = Utility.get_json('..\\config\\cxx_testdata.conf')
#print(test_config_info)
test_add_info = Utility.get_excel_to_tuple(test_config_info[3])
print('test data====', test_add_info)
test_track_info = Utility.get_excel_to_tuple(test_config_info[4])
test_track_resources_info = Utility.get_excel_to_tuple(test_config_info[5])
test_modify_info = Utility.get_excel_to_tuple(test_config_info[6])
test_discard_info = Utility.get_excel_to_tuple(test_config_info[7])
test_prorated_distribution_info = Utility.get_excel_to_tuple(
test_config_info[8])
test_claim_info = Utility.get_excel_to_tuple(test_config_info[9])
test_change_info = Utility.get_excel_to_tuple(test_config_info[10])
class MarketTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.driver = Service.get_driver('..\\config\\base.conf')
from common.login import Login
from util.service import Service
import unittest
from parameterized import parameterized
import time
from util.utility import Utility
test_config_info=Utility.get_json('..\\config\\testdata.conf')
login_info =Utility.get_excel_to_tuple(test_config_info[0])
class TestLogin(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
cls.driver=Service.get_driver('..\\config\\base.conf')
cls.login=Login(cls.driver)
@parameterized.expand(login_info)
def test_login(self,uname,upass,vfcode,expect):
data={'username':uname,'password':upass,'verfifycode':vfcode}
self.login.do_login('..\\config\\base.conf',data)
from selenium.webdriver.common.by import By
if Service.is_element_present(self.driver,By.LINK_TEXT,'注销'):
actual='pass'
self.driver.find_element_by_link_text('注销').click()
else:
actual = 'fail'
self.driver.refresh()
self.assertEqual(actual,expect)
import requests, time
import unittest
from parameterized import parameterized
from werkzeug.wrappers import json
from util.utility import Utility
data_base_path='../config/base.conf'
data_config_path = '../config/testdata.conf'
data_config_info = Utility.get_json(data_config_path)
query_assets_info = Utility.get_excel_to_tuple(data_config_info[6])#查询采购记录
add_assets_info = Utility.get_excel_to_tuple(data_config_info[7])#新增采购记录
addmore_assets_info = Utility.get_excel_to_tuple(data_config_info[8])#批量新增采购记录
modify_assets_info = Utility.get_excel_to_tuple(data_config_info[9])#修改采购记录
query_borlist_info = Utility.get_excel_to_tuple(data_config_info[10])#查询认领记录
add_bor_info = Utility.get_excel_to_tuple(data_config_info[11])#新增认领记录
modify_bor_info = Utility.get_excel_to_tuple(data_config_info[12])#修改认领记录
query_return_info = Utility.get_excel_to_tuple(data_config_info[13])#查询归还记录
class AdministrativeTest(unittest.TestCase):
@parameterized.expand(query_assets_info)
def test_administrative(self,url,method,test_data,resp_code,resp_content,expect):
from common.administrative import Administrative
query_assets_resp = Administrative().query_assets(url,test_data)
query_assets_resp_content = query_assets_resp.json()
# print(query_hr_resp_content)
print(query_assets_resp_content['totalRow'])
#通过数据库查询数据的数量
sql = 'select count(*) from assets;'
import json
import unittest
from parameterized import parameterized
from common.enterprise_manage import EtprsManage
from util.utility import Utility
data_config_path = '../config/testdata.conf'
data_config_info = Utility.get_json(data_config_path)
result_info = Utility.get_excel_to_tuple(data_config_info[2])
print('result_info', result_info)
class BatchManageTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.enterprise_manage = EtprsManage()
# @parameterized.expand(result_info)
# def test_batch_manage(self,url,method,data,resp_code,resp_content):
# resp = self.batch_manage.batch_manage(url, data,filePath)
# if len(resp.json()) > 0:
# actual = 'import success'
# self.assertEqual(actual, resp_content)
@parameterized.expand(result_info)
def test_query_batch(self, url, method, data, resp_code, resp_content):
resp = self.enterprise_manage.query_etprs(url, data)
resp_list = json.loads(resp.text).get('list')
print('resp====', len(resp_list))
import requests, time
import unittest
from parameterized import parameterized
from util.utility import Utility
data_config_path = '../config/testdata.conf'
data_base_path='../config/base.conf'
data_config_info = Utility.get_json(data_config_path)
query_finance_info = Utility.get_excel_to_tuple(data_config_info[1])
class FinanceTest(unittest.TestCase):
@parameterized.expand(query_finance_info)
def test_finance(self,url,method,test_data,resp_code,resp_content,expect):
print(expect)
from common.finance import Finance
query_finance_resp = Finance().query_finance(url,test_data)
query_finance_resp_content = query_finance_resp.text
print(query_finance_resp_content)
sql=''
Utility.query_all(data_base_path,sql)
if '"totalRow":3,"pageNumber":1,"firstPage":true,"lastPage":true,"totalPage":1,"pageSize":10' \
in str(query_finance_resp_content) :
actual = 'query-success'
else:
actual = 'query-fail'
self.assertEqual(actual,expect)
if __name__ == '__main__':
unittest.main(verbosity=2)
#-*- coding:utf-8 -*-
# author JTT
# @Time:2020/4/24 12:18
import requests, time
import unittest
from parameterized import parameterized
from common.student import student
from util.utility import Utility
#基本信息
test_infos = Utility.get_json('..\\config\\jtttestdata.conf')
#学员信息查询测试数据
query_student_infos = Utility.get_excel_to_tuple(test_infos[0])
#学员晨考和作业测试数据
Mornexam_homework_infos = Utility.get_excel_to_tuple(test_infos[1])
#学员周考成绩测试数据
test_upload_weekexam_infos = Utility.get_excel_to_tuple(test_infos[2])
#学员阶段测评测试数据
test_upload_phaseExam_infos = Utility.get_excel_to_tuple(test_infos[3])
#学员综合成绩查询
test_query_comprehensive_infos = Utility.get_excel_to_tuple(test_infos[4])
#学员信息修改测试数
test_edit_student_infos = Utility.get_excel_to_tuple(test_infos[6])
class Student(unittest.TestCase):
#学员信息查询
@parameterized.expand(query_student_infos)
import unittest
from parameterized import parameterized
from common.admin_manage import AdminManage
from util.utility import Utility
data_config_path = '../config/fei_testdata.conf'
data_config_info = Utility.get_json(data_config_path)
test_info = Utility.get_excel_to_tuple(data_config_info[6])
print('test_info', test_info)
class ReportCenterQueryTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.obj = AdminManage()
@parameterized.expand(test_info)
def test_admin_manage(self, url, method, test_data, resp_code,
resp_content):
resp = self.obj.admin_manage(url, test_data)
print('============', resp.text)
if resp_content != 'query_success':
result = resp.text
else:
if resp.json()['pageNumber'] != None:
result = 'query_success'
self.assertEqual(resp_content, result)
from common.login import Login
from common.train_add import Trainadd
import time,unittest
from parameterized import parameterized
from util.service import Service
from util.utility import Utility
test_config_info=Utility.get_json('..\\config\\testdata.conf')
train_add_info=Utility.get_excel_to_tuple(test_config_info[8])
class TrainAddTest(unittest.TestCase):
def setUp(self) -> None:
test_base_info=Utility.get_json('..\\config\\base.conf')
self.driver=Service.get_driver('..\\config\\base.conf')
self.train=Trainadd(self.driver)
self.train.click_train_source()
#测试手机号为空
@parameterized.expand(train_add_info)
def test_add_cus(self,cus_phone,cus_name,cus_sex,cus_status,cus_grade,cus_source,experience,expect):
self.train.add_tel_verify(cus_phone,cus_name,cus_sex,cus_status,cus_grade,cus_source,experience)
time.sleep(3)
try:
add_message=self.train.message()
if add_message == '新增成功.':
actual = 'pass'
elif '属于' in add_message:
actual = 'pass'
else:
actual='fail'
# Author: Administrator
# Date: 2020/2/10
#-------------------------------------------------------------------------------
# 该模块封装与市场营销相关的测试
import time, unittest
from parameterized import parameterized
# 获取登录用的测试信息
from common.market import Market
from util.service import Service
from util.utility import Utility
test_config_info = Utility.get_json('..\\config\\cxx_testdata.conf')
print(test_config_info)
test_query_info = Utility.get_excel_to_tuple(test_config_info[0])
print('test data====', test_query_info)
test_add1_info = Utility.get_excel_to_tuple(test_config_info[1])
print('test data====', test_add1_info)
test_add2_info = Utility.get_excel_to_tuple(test_config_info[2])
class MarketTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.driver = Service.get_driver('..\\config\\base.conf')
cls.common = Market(cls.driver, '..\\config\\base.conf')
@classmethod
def tearDownClass(cls):
cls.driver.quit()
import unittest
from parameterized import parameterized
from util.utility import Utility
data_config_path = '../config/testdata.conf'
data_config_info = Utility.get_json(data_config_path)
query_market_data = Utility.get_excel_to_tuple(data_config_info[12])
print(query_market_data)
add1_data = Utility.get_excel_to_tuple(data_config_info[13])
add2_data = Utility.get_excel_to_tuple(data_config_info[14])
add3_data = Utility.get_excel_to_tuple(data_config_info[15])
class QuestionsBankTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
from common.marketing_management import MarketingManagement
cls.market_obj = MarketingManagement()
@classmethod
def tearDownClass(cls):
pass
# 查询所有题目接口测试
@parameterized.expand(query_market_data)
def test_query_market(self,url,method,test_data,resp_code,resp_content):
query_market_resp = self.market_obj.query_market(url,test_data)
content = query_market_resp.json()
print(content["totalRow"])
if content["totalRow"] == 61:
result = "query ok"
import unittest
from parameterized import parameterized
from common.report_center_query import ReportMarketQuery
from util.utility import Utility
data_config_path = '../config/fei_testdata.conf'
data_config_info = Utility.get_json(data_config_path)
query_market = Utility.get_excel_to_tuple(data_config_info[0])
query_class = Utility.get_excel_to_tuple(data_config_info[1])
query_jobInfo = Utility.get_excel_to_tuple(data_config_info[2])
class ReportCenterQueryTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.obj = ReportMarketQuery()
@parameterized.expand(query_market)
def test_query_market(self, url, method, test_data, resp_code,
resp_content):
resp = self.obj.query_all(url, test_data)
content = resp.json()
print('content=========', resp)
if resp_code == 200:
result = "querry_success"
else:
result = "querry_fail"
self.assertEqual(resp_content, result)
import requests, time
import unittest
from parameterized import parameterized
from werkzeug.wrappers import json
from util.utility import Utility
data_base_path = '../config/base.conf'
data_config_path = '../config/testdata.conf'
data_config_info = Utility.get_json(data_config_path)
query_hr_info = Utility.get_excel_to_tuple(data_config_info[2])
add_hr_info = Utility.get_excel_to_tuple(data_config_info[3])
modify_hr_info = Utility.get_excel_to_tuple(data_config_info[4])
query_attendance_info = Utility.get_excel_to_tuple(data_config_info[5])
class HrTest(unittest.TestCase):
@parameterized.expand(query_hr_info)
def test_hr(self, url, method, test_data, resp_code, resp_content, expect):
from common.HR import HR
query_hr_resp = HR().query_HR(url, test_data)
query_hr_resp_content = query_hr_resp.json()
# print(query_hr_resp_content)
print(query_hr_resp_content['totalRow'])
#通过数据库查询数据的数量
sql = 'select count(*) from employee;'
sql_request = Utility.query_all(data_base_path, sql)
print(sql_request[0][0])
if query_hr_resp_content['totalRow'] == sql_request[0][0]:
actual = 'query-success'
else:
import unittest
from parameterized import parameterized
from common.employee_manage import EmployeeManage
from util.utility import Utility
data_config_path = '../config/fei_testdata.conf'
data_config_info = Utility.get_json(data_config_path)
add_info = Utility.get_excel_to_tuple(data_config_info[3])
modify_info = Utility.get_excel_to_tuple(data_config_info[4])
query_info = Utility.get_excel_to_tuple(data_config_info[5])
class AdminManageTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.obj = EmployeeManage()
@parameterized.expand(add_info)
def test_add(self, url, method, test_data, resp_code, resp_content):
resp = self.obj.add(url, test_data)
print(resp.text)
self.assertEqual(resp_content, resp.text)
@parameterized.expand(modify_info)
def test_modify(self, url, method, test_data, resp_code, resp_content):
resp = self.obj.modify(url, test_data)
self.assertEqual(resp_content, resp.text)
@parameterized.expand(query_info)
import unittest
from common.train_assign import TrainAssign
from util.service import Service
from parameterized import parameterized
from util.utility import Utility
test_config_info=Utility.get_json('..\\config\\testdata.conf')
assign_random=Utility.get_excel_to_tuple(test_config_info[14])
assign_all=Utility.get_excel_to_tuple(test_config_info[15])
class AssignTest(unittest.TestCase):
def setUp(self) -> None:
self.driver=Service.get_driver('..\\config\\base.conf')
self.assign=TrainAssign(self.driver)
@parameterized.expand(assign_random)
def test_assign_to_counselor(self,cus_channel,cus_curriculum,expect):
result=self.assign.do_assign_to_counselor(cus_channel,cus_curriculum)
if result==1:
actual='pass'
else:
actual='fail'
self.assertEqual(actual,expect)
@parameterized.expand(assign_all)
def test_assign_all_to_counselor(self,cus_channel,cus_curriculum,expect):
if self.assign.do_assign_all_to_counselor(cus_channel,cus_curriculum):
actual='pass'
else:
actual='fail'
self.assertEqual(actual,expect)
import unittest
from parameterized import parameterized
from common.train_transmit import TrainTransmit
from util.service import Service
from util.utility import Utility
test_config_info = Utility.get_json('..\\config\\testdata.conf')
query_data = Utility.get_excel_to_tuple(test_config_info[19])
submit_data = Utility.get_excel_to_tuple(test_config_info[20])
class TransmitTest(unittest.TestCase):
def setUp(self) -> None:
self.driver = Service.get_driver('..\\config\\base.conf')
self.transmit = TrainTransmit(self.driver)
@parameterized.expand(query_data)
def test_query(self, origion_region, dept, worker, status, source, expect):
total = self.transmit.do_query(origion_region, dept, worker, status,
source)
if total > 0:
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
@parameterized.expand(submit_data)
def test_do_submit(self, cus_region, user_dept, user_name, cus_status,
cus_source, region_name, dept_name, worker_name,
expect):
total = self.transmit.do_submit(cus_region, user_dept, user_name,
cus_status, cus_source, region_name,
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from selenium.webdriver.common.by import By
from parameterized import parameterized
import unittest
import time
# 获取测试数据
from common.student import Student
from util.service import Service
from util.utility import Utility
student_datas = Utility.get_json("../config/lf_testdata.conf")
student_data = Utility.get_excel_to_tuple(student_datas[4])
path = '..\\config\\base.conf'
class TestStudent(unittest.TestCase):
def setUp(self):
print('test start')
self.driver = Service.get_driver(path)
Service.miss_login(self.driver, path)
self.student = Student(self.driver)
self.student.click_student_manage_link()
def tearDown(self):
time.sleep(2)
self.driver.quit()
from common.train_source import TrainSource
import unittest, time
from parameterized import parameterized
from util.service import Service
from util.utility import Utility
test_config_info = Utility.get_json('..\\config\\testdata.conf')
train_info = Utility.get_excel_to_tuple(test_config_info[1])
train_worker = Utility.get_excel_to_tuple(test_config_info[2])
train_status = Utility.get_excel_to_tuple(test_config_info[3])
train_source = Utility.get_excel_to_tuple(test_config_info[4])
train_time = Utility.get_excel_to_tuple(test_config_info[5])
train_keywords = Utility.get_excel_to_tuple(test_config_info[6])
train_whole = Utility.get_excel_to_tuple(test_config_info[7])
class TrainsourceTest(unittest.TestCase):
def setUp(self) -> None:
self.driver = Service.get_driver('..\\config\\base.conf')
test_base_info = Utility.get_json('..\\config\\base.conf')
self.train = TrainSource(self.driver)
self.train.send_sencpass(test_base_info['erji_pwd_zixun_manager'])
self.train.click_train_source()
@parameterized.expand(train_info)
def test_train_query_pool(self, pool, expect):
self.train.select_pooltype(pool)
total_number = self.train.total_info()
if pool == '临时池':
import time
import unittest
from parameterized import parameterized
from common.train_abandon import TrainAbadon
from util.service import Service
from util.utility import Utility
test_config_info = Utility.get_json('..\\config\\testdata.conf')
abandon_test_info = Utility.get_excel_to_tuple(test_config_info[13])
class AbandonTest(unittest.TestCase):
def setUp(self) -> None:
self.driver = Service.get_driver('..\\config\\base.conf')
self.abandon = TrainAbadon(self.driver)
@parameterized.expand(abandon_test_info)
def test_abandon(self, cus_keyw, expect):
self.abandon.ts.send_keywords(cus_keyw)
self.abandon.ts.click_search()
self.abandon.do_abandon(cus_keyw)
self.abandon.click_public()
time.sleep(2)
try:
abandon_time = self.abandon.query_abandon_time()
if len(abandon_time) > 3:
actual = 'pass'
else:
#-*- coding:utf-8 -*-
# author JTT
# @Time:2020/4/26 20:21
import requests, time
import unittest
from parameterized import parameterized
from common.classmanger import classManager
from util.utility import Utility
#基本信息
test_infos = Utility.get_json('..\\config\\jtttestdata.conf')
#新增班级测试数据
test_add_class_infos = Utility.get_excel_to_tuple(test_infos[10])
#学员考勤测试数据
test_saveAttendance_infos = Utility.get_excel_to_tuple(test_infos[11])
#学员请假测试数据
test_upleave_infos = Utility.get_excel_to_tuple(test_infos[12])
#学员转班测试数据
test_transfer_class_infos = Utility.get_excel_to_tuple(test_infos[13])
class ClassManger(unittest.TestCase):
#新增班级
@parameterized.expand(test_add_class_infos)
#@unittest.skip
def test_add_class(self, URL, METHOD, DATA, CODE, CONTENT, expect):
add_class_infos = {'URL': URL, 'DATA': DATA}
resp = classManager().add_class(add_class_infos)
self.assertEqual(resp.text, CONTENT)
from common.train_add import Trainadd
import time,unittest
from parameterized import parameterized
from util.service import Service
from util.utility import Utility
test_config_info=Utility.get_json('..\\config\\testdata.conf')
train_tel_blank=Utility.get_excel_to_tuple(test_config_info[8])
train_tel_verify=Utility.get_excel_to_tuple(test_config_info[9])
class TrainAddTest(unittest.TestCase):
def setUp(self) -> None:
self.driver=Service.get_driver('..\\config\\base.conf')
self.train=Trainadd(self.driver)
#测试手机号为空
@parameterized.expand(train_tel_blank)
@unittest.skip
def test_add_blank(self,cus_name,cus_status,cus_grade,cus_source,expect):
self.train.add_tel_blank(cus_name,cus_status,cus_grade,cus_source)
time.sleep(3)
try:
add_message=self.train.message()
if add_message=='新增成功.':
actual='pass'
else:
actual='fail'
except:
actual='fail'
finally:
time.sleep(2)