def _load_movie_emb(self, movie_emb_path: str, emb_key: str):
if Config.EMB_DATA_SOURCE == Config.DATA_SOURCE_FILE:
print("Loading movie embedding from %s ..." % movie_emb_path)
valid_emb_count = 0
with open(movie_emb_path) as f:
for movie_raw_emb_data in f:
movie_emb_data = movie_raw_emb_data.split(":")
if len(movie_emb_data) == 2:
m = self.get_movie_by_id(int(movie_emb_data[0]))
if m is None:
continue
m.emb = Utility.parse_emb_str(movie_emb_data[1])
valid_emb_count += 1
print(
"Loading movie embedding completed. %d movie embeddings in total."
% valid_emb_count)
else:
print("Loading movie embedding from Redis ...")
movie_emb_keys = RedisClient.get_instance().keys(
emb_key + "*") # type: Set[str]
valid_emb_count = 0
for movieEmbKey in movie_emb_keys:
movie_id = movieEmbKey.split(":")[1]
m = self.get_movie_by_id(int(movie_id))
if m is None:
continue
m.emb = Utility.parse_emb_str(
RedisClient.get_instance().get(movieEmbKey))
valid_emb_count += 1
print(
"Loading movie embedding completed. %d movie embeddings in total."
% valid_emb_count)
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)
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()
def init_ns(dryrun):
gv.dryrun = dryrun
gv.util = Utility()
# required by following two lines
gv.tpl_vars = {'cwd': os.path.dirname(sys.argv[0])}
gv.logger = get_logger()
gv.conf = get_conf()
def do_login_manager(self, base_config_path):
Service.open_page(self.driver, base_config_path)
info = Utility.get_json(base_config_path)
self.input_name(info['username_manager'])
self.input_upass(info['password_manager'])
self.input_vfcode(info['verifycode'])
self.click_button()
def post_league():
body = request.get_json()
start_date = datetime.strptime(body['start'], DATE_FORMAT)
end_date = datetime.strptime(body['end'], DATE_FORMAT)
if start_date > end_date:
return make_response(jsonify(EndBeforeStart=errors['endBeforeStart']),
400)
league_duration = (end_date - start_date).days
if league_duration > DAYS_IN_YEAR:
return make_response(
jsonify(LeagueDurationTooLong=errors['leagueDurationTooLong']),
400)
start_pos = body.get('startPos') or DEFAULT_START_POS
invite_code = Utility.getInviteCode()
g.cursor.execute(
"Insert INTO League(name, start, end, startPos, inviteCode, ownerId) "
+ "VALUES (%s, %s, %s, %s, %s, %s)", [
body['name'], start_date, end_date, start_pos, invite_code,
g.user['id']
])
return jsonify(inviteCode=invite_code,
id=g.cursor.lastrowid,
startPos=start_pos)
def test_train_query_pool(self, pool, expect):
self.train.select_pooltype(pool)
total_number = self.train.total_info()
if pool == '临时池':
db_pool = 'temp'
elif pool == '公共池':
db_pool = 'public'
elif pool == '个人池':
db_pool = 'private'
elif pool == '学生池':
db_pool = 'student'
elif pool == '全部':
db_pool = '""or 1=1'
else:
db_pool = 0
sql = 'select count(*)as total from customer where pool_type="%s"' % (
db_pool)
result = Utility().db_query_dict('..\\config\\base.conf',
sql)[0]['total']
if int(total_number) == result:
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
def get_driver(cls, base_config_path):
contents = Utility.get_json(base_config_path)
from selenium import webdriver
driver = getattr(webdriver, contents['BROWSER'])()
driver.implicitly_wait(6)
driver.maximize_window()
return driver
def miss_login(cls, driver, base_config_path):
cls.open_page(driver, base_config_path)
# 通过字典方式传递cookie信息
contents = Utility.get_json(base_config_path)
driver.add_cookie({'name': 'token', 'value': contents['token']})
driver.add_cookie({'name': 'workId', 'value': contents['workId']})
cls.open_page(driver, base_config_path)
def test_administrative(self, url, method, test_data, resp_code, resp_content, expect):
# 通过数据库查询数据的数量
sql = 'select count(*) from assets;'
sql_request = Utility.query_all(data_base_path, sql)
from common.administrative import Administrative
add_assets_resp =Administrative().add_assets(url, test_data)
sql = 'select count(*) from assets;'
sql_request1 = Utility.query_all(data_base_path, sql)
print(add_assets_resp.text)
if int(sql_request[0][0]) == int(sql_request1[0][0]) - 1:
actual = 'add-success'
elif add_assets_resp.text =='AlreayExistCode':
actual = 'add-alreay'
else:
actual = 'add-fail'
self.assertEqual(actual, expect)
def test_hr(self, url, method, test_data, resp_code, resp_content, expect):
# 通过数据库查询数据的数量
sql = 'select count(*) from employee;'
sql_request = Utility.query_all(data_base_path, sql)
#新增员工
from common.HR import HR
add_hr_resp = HR().add_HR(url, test_data)
# add_hr_resp_content = add_hr_resp.json()
# print(query_hr_resp_content)
# print(add_hr_resp_content['totalRow'])
sql = 'select count(*) from employee;'
sql_request1 = Utility.query_all(data_base_path, sql)
if int(sql_request[0][0]) == int(sql_request1[0][0]) - 1:
actual = 'add-success'
else:
actual = 'add-fail'
self.assertEqual(actual, expect)
def __init__(self, **kwargs):
self.title = 'Morse Coder'
super().__init__(**kwargs)
self.theme_cls.primary_palette = 'Green'
self.theme_cls.primary_hue = '300'
self.theme_cls.accent_palette = 'Gray'
self.theme_cls.accent_hue = '800'
self.theme_cls.theme_style = 'Dark'
self.accent_color = [1, .25, .5, 1]
self.util = Utility()
def start(self):
from HTMLTestRunner import HTMLTestRunner
ts=unittest.TestSuite()
loader=unittest.TestLoader()
testcases_name=Utility.trans_str('..\\config\\test.conf')
tests=loader.loadTestsFromNames(testcases_name)
ts.addTests(tests)
import time
ctime=time.strftime('%Y%m%d_%H%M%S',time.localtime())
with open('..\\report\\%s_report.html'%(ctime),'w')as file:
runner=HTMLTestRunner(stream=file,verbosity=2)
runner.run(ts)
def test_train_query_source(self, source_name, expect):
self.train.select_source(source_name)
total_number = self.train.total_info()
sql = 'SELECT COUNT(*)total FROM customer WHERE source="%s" AND pool_type NOT IN ("public")' % source_name
result = Utility.db_query_dict('..\\config\\base.conf',
sql)[0]['total']
if result == int(total_number):
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
def get_session(cls):
base_info = Utility.get_json('..\\config\\base.conf')
#login_url = "%s://%s:%s/%s/" %(base_info['PROTOCOL'],base_info['HOSTNAME'],base_info['PORT'],base_info['AURL'])
login_url = 'http://192.168.254.133:8080/WoniuBoss4.0/login/userLogin'
login_data = {
"userName": base_info["USERNAME"],
"userPass": base_info["PASSWORD"],
"checkcode": base_info["VERIFYCODE"]
}
session = requests.session()
session.post(url=login_url, data=login_data)
return session
class MainApp(App):
util = Utility()
# Change APP colors here
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Indigo'
theme_cls.primary_hue = '300'
theme_cls.accent_palette = 'Cyan'
theme_cls.accent_hue = '800'
theme_cls.theme_style = 'Light'
accent_color = [255/255, 64/255, 129/255, 1]
def build(self):
return MainBox(util=self.util)
def test_train_query_status(self, status, expect):
self.driver.refresh()
time.sleep(3)
self.train.select_status(status)
total_number = self.train.total_info()
sql = 'SELECT COUNT(*)AS total from customer a,dictionary_data b WHERE a.last_status=b.dict_key and b.dict_value="%s"AND pool_type NOT IN ("public")' % status
result = Utility().db_query_dict('..\\config\\base.conf',
sql)[0]['total']
if int(total_number) == result:
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
def miss_login(cls, driver, base_config_path):
cls.open_page(driver, base_config_path)
# 通过字典方式传递cookie信息
contents = Utility.get_json(base_config_path)
# driver.add_cookie({'name': 'username', 'value': contents['username']})
# driver.add_cookie({'name': 'password', 'value': contents['password']})
ele1 = driver.find_element_by_name('userName')
ele2 = driver.find_element_by_name('userPass')
ele3 = driver.find_element_by_name('checkcode')
ele1.send_keys('WNCD016')
ele2.send_keys('woniu123')
ele3.send_keys('0000')
driver.find_element_by_css_selector('.btn').click()
def start(self):
from HTMLTestRunner import HTMLTestRunner
ts = unittest.TestSuite()
loader = unittest.TestLoader()
testcase_names = Utility.trans_str('../config/test.conf')
tests = loader.loadTestsFromNames(testcase_names)
ts.addTests(tests)
# 测试报告文件名称的格式为：xxxx-xx-xx_xx_xx_xx_report.html
import time
ctime = time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime())
with open('..\\report\\%s_report.html' % (ctime), 'w') as file:
runner = HTMLTestRunner(stream=file, verbosity=2)
runner.run(ts)
def test_query_student(self, URL, METHOD, DATA, CODE, CONTENT, expect):
query_infos = {'URL': URL, 'DATA': DATA}
resp = student().query_student(query_infos)
result = resp.json()
#按班级查询
if DATA['stuClass'] != '':
SQL = "select s.student_name FROM student AS s,class AS c WHERE s.student_class_id = c.class_id AND c.class_no ='{}'".format(
DATA['stuClass'])
DBresult = Utility.query_all('..\\config\\base.conf', SQL)
#按学生姓名查询
else:
SQL = "select * FROM student AS s,class AS c WHERE s.student_class_id = c.class_id AND s.student_name ='{}'".format(
DATA['stuName'])
DBresult = Utility.query_all('..\\config\\base.conf', SQL)
print(len(DBresult), result['totalRow'])
if int(result['totalRow']) == len(
DBresult) and result['totalRow'] != 0:
auctual = 'query_sucess'
else:
auctual = 'query_fail'
#断言
self.assert_(auctual, expect)
def test_train_query_worker(self, worker_name, expect):
self.driver.refresh()
time.sleep(3)
self.train.select_worker(worker_name)
total_number = self.train.total_info()
sql = 'SELECT COUNT(*)AS total FROM customer a,employee b WHERE a.work_id=b.work_id AND b.employee_name="%s" AND pool_type NOT IN ("public")' % worker_name
result = Utility().db_query_dict('..\\config\\base.conf',
sql)[0]['total']
if int(total_number) == result:
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
def get_session(cls):
base_info = Utility.get_json('../config/base.conf')
login_url = "%s://%s:%s/%s" % (base_info['PROTOCOL'],
base_info['HOSTNAME'],
base_info['PORT'], base_info['AURL'])
login_data = {
"userName": base_info["USERNAME"],
"userPass": base_info["PASSWORD"],
"checkcode": base_info["VERIFYCODE"],
"remember": base_info["REMEMBER"]
}
session = requests.session()
session.post(login_url, login_data)
return session
def test_train_query_worker(self, worker_name, expect):
time.sleep(1)
self.train.select_worker(worker_name)
total_number = self.train.total_info()
time.sleep(2)
sql = 'SELECT COUNT(*)AS total FROM customer a,employee b WHERE b.work_id=a.work_id AND employee_name="%s"' % worker_name
result = Utility().db_query_dict('..\\config\\base.conf',
sql)[0]['total']
if int(total_number) == result:
actual = 'pass'
else:
actual = 'fail'
self.assertEqual(actual, expect)
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_attendance_resp_content = query_hr_resp.json()
# print(query_hr_resp_content)
print(query_attendance_resp_content['totalRow'])
# 通过数据库查询数据的数量
sql = 'select count(*) from attendance;'
sql_request = Utility.query_all(data_base_path, sql)
print(sql_request[0][0])
if query_attendance_resp_content['totalRow'] == sql_request[0][0]:
actual = 'query-success'
else:
actual = 'query-fail'
self.assertEqual(actual, expect)
def _load_user_emb(self, user_emb_path: str, emb_key: str):
if Config.EMB_DATA_SOURCE == Config.DATA_SOURCE_FILE:
print("Loading user embedding from %s ..." % user_emb_path)
valid_emb_count = 0
with open(user_emb_path) as f:
for user_raw_emb_data in f:
user_emb_data = user_raw_emb_data.split(":")
if len(user_emb_data) == 2:
u = self.get_user_by_id(int(user_emb_data[0]))
if u is None:
continue
u.emb = Utility.parse_emb_str(user_emb_data[1])
valid_emb_count += 1
print(
"Loading user embedding completed. %d user embeddings in total."
% valid_emb_count)
def test_administrative(self, url, method, test_data, resp_code, resp_content, expect):
from common.administrative import Administrative
query_borlist_resp = Administrative().query_assets(url, test_data)
query_borlist_resp_content = query_borlist_resp.json()
# print(query_hr_resp_content)
print(query_borlist_resp_content['totalRow'])
# 通过数据库查询数据的数量
sql = 'select count(*) from borrow;'
sql_request = Utility.query_all(data_base_path, sql)
print(sql_request[0][0])
if query_borlist_resp_content['totalRow'] == sql_request[0][0]:
actual = 'query-success'
else:
actual = 'query-fail'
self.assertEqual(actual, expect)
def post_league():
body = request.get_json()
inviteCode = Utility.getInviteCode()
try:
start = time.strptime(body['start'], DATE_FORMAT)
end = time.strptime(body['end'], DATE_FORMAT)
except:
return make_response(jsonify(error=errors['invalidDate']), 400)
g.cursor.execute(
"INSERT INTO League(name, start, end, startPos, inviteCode, ownerId) "
+ "VALUES (%s, %s, %s, %s, %s, %s)", [
body['name'], start, end, body['startPos'], inviteCode,
body['ownerId']
])
return jsonify(inviteCode=inviteCode, id=g.cursor.lastrowid)
def get_rec_list(user_id: int, size: int, model: str):
user = DataManager.get_instance().get_user_by_id(user_id)
if user is None:
return list()
CANDIDATE_SIZE = 800
candiadtes = DataManager.get_instance().get_movies(CANDIDATE_SIZE,
"rating")
if Config.EMB_DATA_SOURCE == Config.DATA_SOURCE_REDIS:
user_emb_key = "uEmb:" + str(user_id)
user_emb = RedisClient.get_instance().get(user_emb_key)
if user_emb is not None:
user.set_emb(Utility.parse_emb_str(user_emb))
ranked_list = ranker(user, candiadtes, model)
if len(ranked_list) > size:
return ranked_list[:size]
return ranked_list
#-*- 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)
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)
