class BaseTestCase(TestCase):
"""
接口测试用例基类
"""
# 引用日志类
log = Logger('执行API测试').get_logger()
@classmethod
def setUpClass(cls) -> None:
cls.log.info('{}开始执行{}'.format('=' * 50, '=' * 50))
# 引用随机数据生成类
cls.faker = FakeData()
# 引用测试结果回写类
cls.back_fill = BackFillToExcel()
# 创建生成器，返回一个迭代器，用于测试用例计数
cls._count_case = (x for x in range(1, 1000))
@classmethod
def tearDownClass(cls) -> None:
# 所有用例执行完毕，数据回写完毕后，保存回写结果
cls.back_fill.save_excel()
cls.log.info('{}执行完毕{}'.format('=' * 50, '=' * 50))
def setUp(self) -> None:
# 每执行一个用例，从迭代器获取一个值，从1开始
self.count = next(self._count_case)
self.log.info('{}准备执行第{}个用例{}'.format('-' * 25, self.count, '-' * 25))
# 第一个回写测试用例编号，确定当前用例的测试结果回写行数
self.back_fill.fill_case_number(self.count)
# 默认回写判定结果为SUCCESS，后续由断言方法改写
self.back_fill.fill_judgement_result()
@property
def timestamp(self):
"""时间戳"""
return int(time())
def check_result(self, excepted: dict, response: dict):
"""
传入预期结果和实际结果，调用数据比对方法获取比对结果，根据比对结果判定用例执行结果
:param excepted: 预期
:param response: 实际
:return: None
"""
# 回写预期结果、响应结果
self.back_fill.fill_excepted(excepted)
self.back_fill.fill_response(response)
self.log.info('预期结果：{}'.format(excepted))
compare_result = DataCompare().compare(excepted, response)
# 回写比对结果
self.back_fill.fill_compare_result(compare_result)
try:
self.assertTrue(compare_result == [])
except AssertionError:
self.log.error('执行结果：FAILURE')
# 若比对结果存在不一致，改写判定结果为FAILURE
self.back_fill.fill_judgement_result(result=0)
raise AssertionError(f'预期结果：{excepted}，比对结果：{compare_result}')
else:
self.log.info('执行结果：SUCCESS')
def __init__(self):
self.log = Logger()
'''获取抽签列表'''
csv_file = csv.reader(open(DRAW_LOTS_WORDS_PATH, 'r', encoding='UTF-8'))
for word in csv_file:
lots_dict[word[0]] = word[1]
words_dict[word[0]] = word[2]
def test_HuanKuan1(self,exist = False):
u"""还款--默认首期"""
print("*************执行 还款-默认首期 用例**************")
params = Params()
try:
self.driver.find_element_by_id("rl_repayment").click() #点击首页中的去还款
time.sleep(2)
self.driver.find_element_by_id("tv_state").click() #选择第一条数据
time.sleep(2)
self.driver.find_element_by_id("tv_repayment").click() #默认首期,直接点击还款
time.sleep(2)
self.driver.find_element_by_id("rl_top").click() #跳转到银行卡管理页,选择第一个
time.sleep(8)
inputText(self,params['applyPWD']) #输入支付密码
time.sleep(8)
exist=is_resultActivity(self) #判断是否成功跳转到了还款成功页
except:
exist = False
#获取当前方法名作为截图名
pic_name = get_current_function_name()
#调用截图方法
getScreen(self,pic_name)
#写入日志
logger=Logger(logname='log.txt',loglevel="INFO",logger=pic_name).getlog()
logger.error(traceback.format_exc())
self.assertEqual(exist, True)
def __init__(self, filename: str, page_number: int):
self._filename = filename
if not self._filename.endswith('.yaml'):
self._filename = filename + '.yaml'
self._page_number = page_number
self._all_result = self._read_all_page()
self._log = Logger('读取定位器').get_logger()
def fetch(config, subreddit):
logger = Logger('main', 'fetch', plain=True)
loaders = []
try:
# pushshift
pushshift = Pushshift(root, config, subreddit)
loaders.append(pushshift)
# crawler
crawler = Crawler(root, config, subreddit)
loaders.append(crawler)
# praw
praw = Praw(root, config, subreddit)
loaders.append(praw)
# start loader threads
background = False # TODO thread implementation
for loader in loaders:
if background:
loader.start()
else:
loader.run()
# wait until abort
while background:
Sleep(1)
except KeyboardInterrupt:
for loader in loaders:
loader.stop(1)
raise KeyboardInterrupt()
except Exception as e:
logger.log(f'...fetch error {repr(e)}')
def train(cfg_name, resume):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f'running on {device}')
cfg = load_cfg(cfg_name)
log = Logger(device=device)
envs = make_vec_envs(**cfg['env'])
model, n_start = init_model(cfg, envs, device, resume)
runner = EnvRunner(rollout_size=cfg['train']['rollout_size'],
envs=envs,
model=model,
device=device)
optim = ParamOptim(**cfg['optimizer'], params=model.parameters())
agent = Agent(model=model, optim=optim, **cfg['agent'])
cp_iter = cfg['train']['checkpoint_every']
log_iter = cfg['train']['log_every']
n_end = cfg['train']['steps']
cp_name = cfg['train']['checkpoint_name']
for n_iter, rollout in zip(trange(n_start, n_end), runner):
agent_log = agent.update(rollout)
if n_iter % log_iter == 0:
log.output({**agent_log, **runner.get_logs()}, n_iter)
if n_iter > n_start and n_iter % cp_iter == 0:
f = cp_name.format(n_iter=n_iter // cp_iter)
torch.save(model.state_dict(), f)
def main(experiment_name, _run):
# Create logger
logger = Logger(experiment_name,
loggers=['tensorboard', 'sacred'],
sacred_run=_run)
# Call train
train(logger=logger, experiment_name=experiment_name)
def __init__(self, val_loader, args, **kwargs):
self.val_loader = val_loader
self.args = args
self.model = get_model(args)
self.step = 0
self.cuda = self.args.cuda
self.log_path = (
PROJECT_ROOT / Path("experiments") /
Path(datetime.now().strftime("%Y%m%d%H%M%S") + "-")).as_posix()
self.log_path = Path(self.get_dirname(self.log_path, args))
if not Path.exists(self.log_path):
Path(self.log_path).mkdir(parents=True, exist_ok=True)
self.logger = Logger("defense", self.log_path, args.verbose)
self.logger.log("Checkpoint files will be saved in {}".format(
self.log_path))
self.logger.add_level("ATTACK", 21, 'yellow')
self.logger.add_level("DEFENSE", 22, 'cyan')
self.logger.add_level("TEST", 23, 'white')
self.logger.add_level("DIST", 11, 'white')
self.kwargs = kwargs
if args.domain_restrict:
self.artifact = get_artifact(self.model, val_loader, args)
self.kwargs['artifact'] = self.artifact
class SlackBot(object):
logger = Logger('SlackBot')
def __init__(self):
return None
def handle_command(self, command):
response = None
try:
if command == 'help' or command == '도움말':
response = "관련 단어를 사용합니다."
if command == 'all' or command == '전체':
from menu.views import search_all
response = search_all()
except Exception as e:
self.logger.debug(e)
response = "오류"
return response
def start(self):
self.logger.debug('Starter Bot connected and running!')
return None
def __init__(self, database_config_path, source_name, domain, encode,
request_interval):
self.logger = Logger("crawler", domain)
self.adapter = DocRawAdapter(database_config_path, source_name,
self.logger)
self.domain = domain
self.encode = encode
self.request_interval = request_interval
def test_get_log_level(self, mock_read_config_json_file):
"""
:param:
:return:
"""
call_class = Logger("1")
nfv_config = {"log_level": "INFO"}
mock_read_config_json_file.return_value = nfv_config
call_class.get_log_level()
def __init__(self, hook_name, config_file="config.json"):
self.config_file = config_file
self.hook_name = hook_name
with open(config_file, 'r') as f:
data = json.load(f)
self.config_data = data["webhooks"][hook_name]
self.delay = self.config_data["sending-delay"]
self.logger = Logger(hook_name, config_file=config_file)
self.logger.info("Initialized")
def test_debug(self):
"""
:param:
:return:
"""
logger = Logger(mock.Mock())
message = logger.prepend_message_type(mock.Mock(), mock.Mock())
logger._logger = mock.Mock()
logger._logger.debug(message)
def init_logger(job_type, flags):
dir_path = os.getcwd()
time_str = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
run_id = str(uuid.uuid4())[:8]
dir_str = '{}-{}-{}'.format(job_type, time_str, run_id)
log_dir = os.path.join(dir_path, job_type, dir_str)
os.makedirs(log_dir, exist_ok=True)
logger = Logger(log_dir=log_dir, flags=flags)
return logger
def __init__(self, api_dict: dict):
super().__init__()
self._log = Logger('发送请求').get_logger()
self._api = api_dict
self._session = requests.Session()
self._log.info('接口名称：{}'.format(self._api.get('name')))
self._set_url(self._api.get('url'))
if self._api.get('headers'):
self.set_headers(self._api.get('headers'))
def init_logger(app):
log_name = 'app'
app.config['JSON_AS_ASCII'] = False
log_level = app.config['LOG_LEVEL']
log_file = app.config['LOG_FILE_CONFIG']['app']
log_dir = os.path.dirname(log_file)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
app.logger = Logger(log_name, log_level, log_file).get_logger()
def logger(request):
'''全局logger'''
date = time.strftime("%Y-%m-%d_", time.localtime())
browser = request.config.getoption("--browser")
dir_path = os.path.join(cwd, 'logs')
_logger = Logger(file_name=date + browser + '.log',
dir_path=dir_path,
console=False)
return _logger
def setUp(self):
TestCase.setUp(self)
self.logger = Logger(output_dir=test_logdir)
self.protocol = MockProtocol('aim', 'digsby03')
self.account = MockAccount('aim', 'digsby03')
self.self_buddy = MockBuddy('digsby03', self.protocol)
self.buddy = MockBuddy('digsby01', self.protocol)
self.convo = MockConversation(buddy=self.buddy,
ischat=False,
protocol=self.protocol)
def test(idx, args, T, shared_net, path):
device = torch.device("cuda")
torch.manual_seed(args.seed + idx)
if args.cuda:
torch.cuda.manual_seed(args.seed + idx)
env = make_env(args.env,
stack_frames=args.stacked_frames,
max_episode_steps=args.max_episode_steps,
episodic_life=True,
reward_clipping=False)
env.seed(args.seed + idx)
state = env.reset()
state_v = torch.from_numpy(state).float().to(device)
hx = torch.zeros(1, 512).to(device)
cx = torch.zeros(1, 512).to(device)
info = True # game is real done, not end of a life (EpisodicLife)
net = A3C_LSTM(env.observation_space.shape[0],
env.action_space.n).to(device)
net.eval()
logger = Logger(name="test",
path=path,
model=shared_net,
start_time=time.time(),
print_log=True,
save_model=True)
while T.value < args.num_timesteps:
# Synchronize thread-specific parameters
if info:
net.load_state_dict(shared_net.state_dict())
# Perform action according to policy
with torch.no_grad():
value_v, logit_v, (hx, cx) = net(state_v.unsqueeze(0), (hx, cx))
prob_v = F.softmax(logit_v, dim=1)
action_v = torch.multinomial(prob_v, num_samples=1)
action = int(action_v.item())
# Receive reward and new state
state, reward, done, info = env.step(action)
state_v = torch.from_numpy(state).float().to(device)
logger.log(T.value, reward, info)
if done:
state = env.reset()
state_v = torch.from_numpy(state).float().to(device)
hx = torch.zeros(1, 512).to(device)
cx = torch.zeros(1, 512).to(device)
def __init__(self, data_adapter_config_path, source_name, schema_file):
'''
Constructord
'''
self.logger = Logger("cleaner", source_name)
self.data_raw_adapter = DataRawAdapter(data_adapter_config_path,
source_name, self.logger)
self.data_clean_adapter = DataCleanAdapter(data_adapter_config_path,
source_name, self.logger)
self.source_name = source_name
self.get_schema(schema_file)
def test_reset_pwd(self):
u'''忘记密码'''
print("*************执行忘记密码用例**************")
params = Params()
try:
self.driver.find_element_by_id("iv_head").click() #点击头像到个人中心页
time.sleep(2)
self.driver.find_element_by_id("rl_top").click() #点击个人中心页中的登录,跳转到登录页
time.sleep(2)
self.driver.find_element_by_id('tv_forgetpwd').click() #跳转到登录页,点击忘记密码
time.sleep(2)
#异常情况
self.driver.find_element_by_id('et_phonenum').send_keys(params['phone']) #输入手机号,其他不输入
self.driver.find_element_by_id('tv_queren_reset').click() #点击确认重置
time.sleep(2)
self.driver.find_element_by_id('et_phonenum').send_keys(params['phone']) #输入手机号
self.driver.find_element_by_id('tv_getAuthCode').click() #获取短信验证码
sms_yanzhengma = input("请输入短信验证码:") #手动输入
time.sleep(8)
self.driver.find_element_by_id('et_authcode').send_keys(sms_yanzhengma) #脚本自动输入短信验证码
time.sleep(2)
self.driver.find_element_by_id('et_pwd').send_keys(params['loginPWD']) #输入密码
time.sleep(2)
self.driver.find_element_by_id('et_queren_pwd').send_keys("111111") #再次输入密码不一致
self.driver.find_element_by_id('tv_queren_reset').click() #点击确认重置
#正确情况
self.driver.find_element_by_id('et_phonenum').send_keys(params['phone']) #输入手机号
self.driver.find_element_by_id('tv_getAuthCode').click() #获取短信验证码
sms_yanzhengma = input("请输入短信验证码:") #手动输入
time.sleep(8)
self.driver.find_element_by_id('et_authcode').send_keys(sms_yanzhengma) #脚本自动输入短信验证码
time.sleep(2)
self.driver.find_element_by_id('et_pwd').send_keys(params['loginPWD']) #输入密码
time.sleep(2)
self.driver.find_element_by_id('et_queren_pwd').send_keys(params['loginPWD']) #再次输入密码
self.driver.find_element_by_id('tv_queren_reset').click() #点击确认重置
exist = False
try:
self.driver.find_element_by_id('tv_queren_reset').click() #判断是否还存在确认按钮,确认是否成功修改
print("输入密码有误")
exist = True
except Exception as e:
pass
except:
exist = True
pic_name = get_current_function_name() #获取当前用例名
getScreen(self,pic_name) #调用截图方法
logger=Logger(logname='log.txt',loglevel="INFO",logger=pic_name).getlog()
logger.error(traceback.format_exc())
self.assertEqual(exist, False) #修改失败,确认按钮存在
def scratch_logger(self):
SCRATCH = 'scratch' # directory to store temp logs
if os.path.isdir(SCRATCH):
self.assert_(False, 'scratch directory should not exist already')
os.makedirs(SCRATCH)
self.assert_(os.path.isdir(SCRATCH))
try:
logger = Logger(output_dir=SCRATCH)
yield logger
finally:
shutil.rmtree(SCRATCH)
def setUp(self) -> None:
self.flag = True
self.log = Logger()
self.start = time.perf_counter()
self.log.info("============【{}测试用例开始】====================".format(self.__class__.__name__))
self.driver.implicitly_wait(10)
self.base = Base_Page(self.driver, self.log)
self.log.info("【操作系统】：" + str(platform.platform()))
self.log.info("【浏览器】：" + login_loc['browserType'])
self.driver.get(login_loc['URL_TEST'])
self.log.info("【打开URL】：" + login_loc['URL_TEST'])
self.base.wait(1)
def main():
initialize_log()
config_params = parse_config_params()
try:
os.mkdir("datavolume1/server")
except FileExistsError:
logging.info("path server/ already exists")
os.chdir("datavolume1/server")
# docs de manager.dict(): https://docs.python.org/3/library/multiprocessing.html#sharing-state-between-processes
manager = Manager()
# the following variable will be set to False by the server when a termination msg is received.
# The backup requester will run as long as this bool indicates the server should be kept running.
keep_server_running = Value(c_bool, True)
# Nodes manager uses this queue to send the nodes
# which need to be backed up to the Backup requester
admin_to_nodes_manager_msgs_queue = Queue()
# Used to signal that a backup is needed
node_to_backup_queue_from_node_manager_to_backup_requester = Queue()
logger_queue = Queue()
# Initialize server and start server loop
server = Server(config_params["port"], config_params["listen_backlog"],
keep_server_running, admin_to_nodes_manager_msgs_queue,
logger_queue)
node_manager = NodeManager(
keep_server_running, admin_to_nodes_manager_msgs_queue,
node_to_backup_queue_from_node_manager_to_backup_requester,
logger_queue)
backup_requester = BackupRequester(
node_to_backup_queue_from_node_manager_to_backup_requester,
logger_queue)
logger = Logger(logger_queue, "logger.log")
p1 = Process(target=server.run)
p2 = Process(target=backup_requester.run)
p3 = Process(target=node_manager.run)
p4 = Process(target=logger.run)
p1.start()
p2.start()
p3.start()
p4.start()
p1.join()
p2.join()
p3.join()
p4.join()
class TestIm(unittest.TestCase):
log = Logger("TestIm")
def setUp(self):
warnings.simplefilter("ignore", ResourceWarning)
self.log.get_log().debug("开始执行用例TestIm...")
def tearDown(self):
self.log.get_log().debug("结束执行用例TestIm...")
def test_ipt_01(self):
# 同患者产生两个任务，任务一是组a，任务二是组b和组a
tem = Template()
def test_credit_addCard(self):
u'''授信'''
print("*****************执行授信用例****************")
params = Params()
self.driver.find_element_by_id("tv_apply").click() #点击马上申请
try:
self.driver.find_element_by_id("tv_id_verify").click() #点击实名认证
time.sleep(2)
self.driver.find_element_by_id("et_cardusername").send_keys(
params['username']) #输入持卡人姓名
self.driver.find_element_by_id("et_idnum").send_keys(
params['ID']) #输入身份证号
time.sleep(2)
exist = False
while exist == False:
self.driver.find_element_by_id(
"et_bankcardnum").click() #输入银行卡号,4位一个空格
input_text.inputText(self, params['cardNumber']) #调用了延时方法输入
self.driver.find_element_by_id("et_phone").send_keys(
params['phone']) #输入手机号
self.driver.find_element_by_id("tv_next").click() #点击下一步
time.sleep(2)
try:
self.driver.find_element_by_id(
"et_idnum").click() #输入银行卡信息有误
print("输入银行卡信息有误")
self.driver.find_element_by_id("iv_delete_idcard").click()
time.sleep(2)
except:
exist = True
sms_yanzhengma = input("请输入短信验证码:") #输入手机验证码
time.sleep(8)
self.driver.find_element_by_id("et_authcode").send_keys(
sms_yanzhengma)
self.driver.find_element_by_id('tv_next').click() #点击下一步
time.sleep(15)
try:
self.driver.find_element_by_id("tv_complete").click() #点击跳过按钮
exist = False
except:
print("短信验证码有误")
except:
print("授信失败")
pic_name = get_current_function_name() #获取当前方法名作为截图名
get_screen.getScreen(self, pic_name) #调用截图方法
logger = Logger(logname='log.txt',
loglevel="INFO",
logger=pic_name).getlog()
logger.error(traceback.format_exc()) #写入日志
self.assertEqual(exist, False)
def __init__(self, default_params_filename='params.yaml', *args, **kwargs):
# Extend the dictionary with the values passed in arguments.
# Call the Dictionary constructor once the parameters file is set.
arguments = Arguments(args, kwargs)
if arguments.args.config_file is not None:
parameters_file = arguments.args.config_file[0]
else:
parameters_file = default_params_filename
super().__init__(parameters_file, *args)
for possible_action in arguments.possible_actions:
setattr(self, possible_action, False)
setattr(self, arguments.args.action, True)
# setattr(self, 'do_plot', arguments.args.plot)
self.do_plot = arguments.args.plot
self.save_predictions = arguments.args.save
self.input_file = arguments.args.file[0]
if arguments.args.window is not None:
self.window_size = arguments.args.window[0]
else:
self.window_size = 10
if arguments.args.epochs is not None:
self.epochs = arguments.args.epochs[0]
else:
self.epochs = 1
# Output filename specified
if arguments.args.output is not None:
self.output = arguments.args.output[0]
else:
self.output = None
#
# Extend the dictionary with custom meta-parameters
#
self.ohlc_tags = list(list(self.csv_dict.keys())[1:])
#
# Set log_level and start the logger
#
setattr(self, 'log_level',
arguments.args.debug[0] if arguments.args.debug is not None \
else 3)
if 'log_level' not in self:
self.log_level = 3 # default value = WARNING
self.log = Logger(self.log_level)
self.log.info(
'Using configuration parameters from: {}'.format(parameters_file))
def test_otp_2_igraph_import(self):
graph = convert_otp_graph_to_igraph(
node_csv_file='data/test_nodes.csv',
edge_csv_file='data/test_edges.csv',
hma_poly_file='data/HMA.geojson',
igraph_out_file='temp/test_graph.graphml',
b_export_otp_data_to_gpkg=False,
b_export_decomposed_igraphs_to_gpkg=False,
b_export_final_graph_to_gpkg=False,
debug_otp_graph_gpkg=None,
debug_igraph_gpkg=None,
log=Logger())
self.assertEqual(graph.ecount(), 3702)
self.assertEqual(graph.vcount(), 1328)
def __init__(self):
self.log = Logger()
'''训练QA样本，获得QA映射表'''
csv_file = csv.reader(open(RESOURCES_PATH, 'r', encoding='UTF-8'))
for QA in csv_file:
tags = jieba.analyse.extract_tags(QA[0], topK=3)
key = ''
for tag in tags:
key += tag
if (len(key)):
QA_dict[key] = QA[1]
else:
QA_dict[QA[0]] = QA[1]
self.log.info("Dict:{}".format(QA_dict))
def test_login(cls, case_list):
for caseName, caseInfo in case_list.items():
caseName = caseName
case_data = caseInfo['data']
case_check = caseInfo['check']
res = cls.client.send(cls.url,
method=cls.method,
headers=cls.headers,
params=case_data)
res.encoding = 'UTF-8'
text = res.text
text_dict = json.loads(text)
Logger().writeLog(caseName, cls.url, case_data, case_check, text_dict)
AssertCheck().check(case_check, text_dict)
