class TestCuringTeamManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pctm = PageCuringTeamManage(cls.driver)
cls.pctm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
@allure.step(title="养护小组管理点击")
def test_curing_team_manage_click(self):
self.pctm.curing_team_manage_click()
@parameterized.expand(read_txt(""))
@allure.step(title="养护小组管理新增")
def test_curing_team_manage_insert(self, team_name, desc):
self.pctm.curing_team_manage_insert(team_name, desc)
# 测试养护小组新增、查看、编辑
def test_curing_team_manage_edit(self):
self.pctm.curing_team_manage_edit(page.public_value, page.public_value)
# 测试重置
def test_curing_team_manage_reset(self):
self.pctm.curing_team_manage_reset()
# 测试查看
def test_curing_team_manage_watch(self):
self.pctm.curing_team_manage_watch()
class TestEmployee(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api=ApiEmployee()
@parameterized.expand(read_txt("employee_post.txt"))
def test01_post(self,username,mobile,workNumber):
r = self.api.api_post_employee(username,mobile,workNumber)
print("新增员工后结果:",r.json())
api.user_id=r.json().get("data").get("id")
print("新增的员工id为",api.user_id)
assert_common(self,r)
def test02_put(self,username="******"):
r = self.api.api_put_employee(username)
print("更新员工姓名为:",r.json())
assert_common(self,r)
def test03_get(self):
r =self.api.api_get_employee()
print("查询姓名为",r.json())
assert_common(self,r)
def test04_delect(self):
r =self.api.api_delete_employee(api.user_id)
print(r.json())
assert_common(self, r)
class TestCuringTeamManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pcut = PageCuringUrgencyTask(cls.driver)
cls.pcut.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试紧急养护点击
def test_curing_urgency_task_click(self):
self.pcut.curing_urgency_task_click()
# 测试异常新增输入
@parameterized.expand(read_txt("/"))
def test_curing_urgency_task_insert(self, task_name, content, remark):
self.pcut.curing_urgency_task_insert(task_name, content, remark)
# 测试新增到编辑
def test_curing_urgency_task_edit(self):
self.pcut.curing_urgency_task_edit(page.public_value,
page.public_value,
page.public_value,
page.public_value,
page.public_value2)
class TestMp:
# 初始化
def setup_class(self):
# 获取ApiMp对象
self.mp = ApiMp()
@pytest.mark.parametrize("mobile,code", read_txt("mp_login.txt"))
def test01_mp_login(self, mobile, code):
"""
登录测试方法
:param mobile: 手机号
:param code: 验证码
:return:
"""
# 调用登录接口方法
r = self.mp.api_mp_login(mobile, code)
# 提取token
ToolsInter.get_token(r)
# 断言
print(r.json())
ToolsInter.assert_common(r)
#
@pytest.mark.parametrize("title, content, channel_id,channel_name",
read_txt("mp_article.txt"))
def test02_mp_article(self, title, content, channel_id, channel_name):
"""
发布文章测试用例
:param title: 文章标题
:param content: 文章内容
:param channel_id:
:param channel_name:
:return:
"""
# 调用发布文章接口方法
r = self.mp.api_mp_article(title, content, channel_id)
# 发布文章成功id，生成文章id---审核文章使用
api.article_id = r.json().get("data").get("id")
# 断言
ToolsInter.assert_common(r)
class TestRoleManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pm = PageRoleManage(cls.driver)
cls.pm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试角色管理新增
@allure.step(title="角色管理新增成功")
# @pytest.mark.run(order=1)
def test_role_manage_insert(self):
self.pm.role_manage_insert(page.public_value, page.public_value,
page.public_value)
# 测试角色管理异常新增
@parameterized.expand(read_txt("system_manage/system_role.txt"))
@allure.step(title="角色管理异常新增,预期失败")
# @pytest.mark.run(order=2)
def test_role_manage_except_insert(self, rolename, rolecode, roledesc,
success):
self.pm.role_manage_insert(rolename, rolecode, roledesc)
if success:
try:
self.pm.page_role_manage_input_return()
except:
self.pm.base_get_image()
# 测试角色管理查看
@allure.step(title="角色管理查看")
# @pytest.mark.run(order=3)
def test_role_manage_watch(self):
self.pm.role_manage_watch()
# 测试角色权限
@allure.step(title="角色管理权限")
# @pytest.mark.run(order=4)
def test_role_manage_power(self):
self.pm.role_manage_power()
# 测试角色编辑
@allure.step(title="角色管理编辑")
# @pytest.mark.run(order=5)
def test_role_manage_edit(self):
self.pm.role_manage_edit()
class TestDeptManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.putm = PageUnitsTypeManage(cls.driver)
cls.putm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试部件型号管理点击
@allure.step(title="部件型号管理点击")
def test_units_type_manage_click(self):
self.putm.units_type_manage_click()
# 测试异常数据部件型号新增
@parameterized.expand(read_txt("base_info_manage/units_type.txt"))
@allure.step(title="部件型号管理输入异常数据新增")
def test_units_type_manage_insert(self, units_type, brand_name,
effective_time, guarantee_num, desc,
success):
self.putm.units_type_manage_insert(units_type, brand_name,
effective_time, guarantee_num, desc)
if success:
try:
self.putm.page_units_type_manage_return_button()
except:
self.putm.base_get_image()
# 测试新增、查询、编辑
@allure.step(title="部件型号管理新增、查询到编辑")
def test_units_type_manage_edit(self):
self.putm.units_type_manage_edit(page.public_value, page.public_value,
page.public_order_num,
page.public_order_num,
page.public_value)
# 测试查看
@allure.step(title="部件型号管理查看")
def test_units_type_manage_watch(self):
self.putm.units_type_manage_watch()
# 测试重置
@allure.step(title="部件型号管理重置")
def test_units_type_manage_reset(self):
self.putm.units_type_manage_reset()
class Test_agent:
# 初始化
def setup_class(self):
# 获取ApiMp对象
self.mp = Api_agent()
# 看房测试方法
@pytest.mark.parametrize("brokerid,cityid", read_txt("key_word.txt"))
def test01_mp_list(self, brokerid, cityid):
# 调用看房列表方法
r = self.mp.api_agent_list(brokerid, cityid)
# # 提取token
# tool.Tools.get_token(r)
# 断言
tool.Tools.agent_assert_common(r)
class Test_official:
# 初始化
def setup_class(self):
# 获取ApiMp对象
self.mp = Api_official_live()
# 看房测试方法
@pytest.mark.parametrize("businesstype", read_txt("Personal_Center.txt"))
def test01_mp_list(self, businesstype):
# 调用看房列表方法
r = self.mp.api_official_live(businesstype)
# # 提取token
# tool.Tools.get_token(r)
# 断言
tool.Tools.official_assert_common(r)
class TestDeptManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pcim = PageCuringItemManage(cls.driver)
cls.pcim.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
@allure.step(title="养护项目管理点击")
def test_curing_item_manage_click(self):
self.pcim.curing_item_manage_click()
@parameterized.expand(read_txt("curing_work_manage/curing_item.txt"))
@allure.step(title="养护项目管理输入异常数据新增")
def test_curing_item_manage_insert(self, units_name, max_period,
main_period, place_desc, remarks,
success):
self.pcim.curing_item_manage_insert(units_name, max_period,
main_period, place_desc, remarks)
if success:
try:
self.pcim.page_curing_item_manage_return_click()
except:
self.pcim.base_get_image()
# 测试养护项目管理新增、查看、编辑
@allure.step(title="养护项目管理新增、查看到编辑")
def test_curing_item_manage_edit(self):
self.pcim.curing_item_manage_edit(page.public_value,
page.public_order_num,
page.public_order_num,
page.public_value, page.public_value)
# 测试重置
@allure.step(title="养护项目管理重置")
def test_curing_item_manage_reset(self):
self.pcim.curing_item_manage_reset()
# 测试查看
@allure.step(title="养护项目管理查看")
def test_curing_item_manage_watch(self):
self.pcim.curing_item_manage_watch()
class TestCuringTeamManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pmtrm = PageMaintenanceRecordManage(cls.driver)
cls.pmtrm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 点击维修记录管理
def test_maintenance_record_manage_click(self):
self.pmtrm.maintenance_record_manage_click()
@parameterized.expand(read_txt("curing_work_manage/maintenance_record.txt")
)
def test_maintenance_record_manage_except_insert(self, content, price,
desc, remark, success):
self.pmtrm.maintenance_record_manage_insert(content, price, desc,
remark)
if success:
try:
self.pmtrm.page_maintenance_record_manage_return_click()
except:
self.pmtrm.base_get_image()
# 新增
def test_maintenance_record_manage_insert(self):
self.pmtrm.maintenance_record_manage_insert(page.public_value,
page.public_order_num,
page.public_value,
page.public_value)
# 编辑
def test_maintenance_record_manage_edit(self):
self.pmtrm.maintenance_record_manage_edit(page.public_value_num2,
page.public_order_num,
page.public_value_num2,
page.public_value_num2)
# 查看
def test_maintenance_record_manage_watch(self):
self.pmtrm.maintenance_record_manage_watch()
class TestDeptManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pd = PageDeptManage(cls.driver)
cls.pd.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试部门管理新增
@allure.step(title="测试部门管理正常数据新增")
# @pytest.mark.run(order=1)
def test_dept_manage_insert(self):
self.pd.dept_manage_insert(page.public_value, page.public_password, page.public_value, page.public_value,
page.public_moile_phone, page.public_value, page.public_password)
# 测试部门管理新增异常数据
@parameterized.expand(read_txt("system_manage/system_dept.txt"))
@allure.step(title="测试部门管理异常数据新增")
# @pytest.mark.run(order=2)
def test_dept_manage_except_insert(self, dept_name, dept_number, desc_duty, line_persion_name, line_phone,
manage_persion_name, order, success):
self.pd.dept_manage_insert(dept_name, dept_number, desc_duty, line_persion_name, line_phone,
manage_persion_name, order)
if success:
try:
self.pd.page_dept_manage_insert_return()
except:
self.pd.base_get_image()
# 测试部门管理编辑
@allure.step(title="测试部门管理正常数据编辑")
# @pytest.mark.run(order=3)
def test_dept_manage_edit(self):
self.pd.dept_manage_edit(page.public_value, page.public_value, page.public_value, page.public_moile_phone,
page.public_value, page.public_password)
# 测试部门管理查看
@allure.step(title="测试部门管理查看")
# @pytest.mark.run(order=4)
def test_dept_manage_watch(self):
self.pd.dept_manage_watch()
class TestMis:
def setup_class(self):
"""
初始化
:return:
"""
# 获取ApiMis对象
self.mis = ApiMis()
@pytest.mark.parametrize("account, pwd", read_txt("mis_login.txt"))
def test01_mis_login(self, account, pwd):
"""
管理员 登录测试方法
:param account: 管理员账号
:param pwd: 密码
:return:
"""
# 调用登录接口方法
rep = self.mis.api_mis_login(account, pwd)
# 提取token
ToolsInter.get_token(rep)
# 断言
print(rep.json())
ToolsInter.assert_common(rep)
def test02_mis_search(self):
"""
查询文章测试用例
:return:
"""
# 调用查询接口方法
rep = self.mis.api_mis_search()
# 断言
ToolsInter.assert_common(rep, code=200)
def test03_mis_audit(self):
"""
审核文章测试用例
:return:
"""
# 调用审核接口 方法
rep = self.mis.api_mis_audit()
# 断言
ToolsInter.assert_common(rep)
class TestCuringTeamManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pcpm = PageCuringPlanManage(cls.driver)
cls.pcpm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 点击养护计划管理
def test_01_curing_plan_manage_click(self):
self.pcpm.curing_plan_manage_click()
# 养护计划管理新增
@parameterized.expand(read_txt("curing_work_manage/curing_plan.txt"))
def test_02_curing_plan_manage_except_insert(self, plan_name, content,
remark, success):
self.pcpm.curing_plan_manage_except_insert(plan_name, content, remark)
if success:
try:
self.pcpm.page_curing_plan_manage_insert_return_click()
except:
self.pcpm.base_get_image()
# 养护计划管理编辑
def test_03_curing_plan_manage_edit(self):
self.pcpm.curing_plan_manage_edit(page.public_value, page.public_value,
page.public_value, page.public_value)
# 测试查看
def test_04_curing_plan_manage_watch(self):
self.pcpm.curing_plan_manage_watch(page.public_value)
# 测试禁用
def test_05_curing_plan_manage_disable(self):
self.pcpm.curing_plan_manage_disable(page.public_value)
# 测试延迟
def test_06_curing_plan_manage_delay(self):
self.pcpm.curing_plan_manage_delay(page.public_value,
page.public_order_num)
class TestEmployee(unittest.TestCase):
# 初始化
@classmethod
def setUpClass(cls):
# 获取ApiEmployee对象
cls.api = ApiEmployee()
# 新增员工
@parameterized.expand(read_txt('employee_data.txt'))
# def test01_post(self,username="******",mobile="18712345678",workNumber="524865"):
def test01_post(self, username, mobile, workNumber):
# 调用新增接口
r = self.api.api_add_employee(username, mobile, workNumber)
print("新增员工后结果为:", r.json())
# 提取员工id
api.user_id = r.json().get("data").get("id")
print("新增员工id为:", api.user_id)
# 断言
assert_common(self, r)
# 更新
def test02_put(self, username="******"):
r = self.api.api_put_employee(username)
print("更新后员工姓名后的结果为:", r.json())
#断言
assert_common(self, r)
# 查询
def test03_get(self):
r = self.api.api_get_employee()
print("查询员工名称结果为:", r.json())
# 断言
assert_common(self, r)
# 删除
#调用delete方法
def test_delete(self):
r = self.api.api_delete_employee(api.user_id)
print("删除后数据结果为:", r.json())
# 断言
assert_common(self, r)
class TestUserManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.um = TestPageUserManage(cls.driver)
cls.um.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试新增
@parameterized.expand(read_txt("system_manage/system_user.txt"))
@allure.step(title="用户管理新增参数化(等价类边界值)")
# @pytest.mark.run(order=1)
def test_user_manage_insert(self, username, password, sure_password, success):
self.um.user_manage_insert(username, password, sure_password)
if success:
try:
self.um.page_user_manage_insert_return_button()
except:
self.um.base_get_image()
# 测试用户管理新增、查询、编辑
@allure.step(title="用户管理的新增到编辑")
# @pytest.mark.run(order=2)
def test_user_manage_edit(self):
self.um.user_manage_edit(page.public_value, page.public_password, page.public_password)
# 测试用户管理的重置
@allure.step(title="用户管理重置")
# @pytest.mark.run(order=3)
def test_user_manage_reset(self):
self.um.user_manage_reset()
# 测试用户管理的禁用
@allure.step(title="用户管理禁用")
# @pytest.mark.run(order=4)
def test_user_manage_ban(self):
self.um.user_manage_ban(page.public_value2, page.public_password, page.public_password)
class TestDeptManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pcdsm = PageCuringDutySonManage(cls.driver)
cls.pcdsm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试养护职责子管理点击
@allure.step(title="养护职责子管理点击")
def test_curing_duty_son_click(self):
self.pcdsm.curing_duty_son_click()
# 测试养护职责子管理新增
@parameterized.expand(read_txt("curing_work_manage/curing_duty_son.txt"))
@allure.step(title="养护职责子管理异常数据新增")
def test_curing_duty_son_insert(self, curing_name, success):
self.pcdsm.curing_duty_son_except_insert(curing_name)
if success:
try:
self.pcdsm.page_curing_duty_son_return_click()
except:
self.pcdsm.base_get_image()
# 测试养护职责管理的新增、查询、编辑
@allure.step(title="养护职责子管理新增、查询到编辑")
def test_curing_duty_son_edit(self):
self.pcdsm.curing_duty_son_edit(page.public_value)
# 测试重置
@allure.step(title="养护职责子管理重置")
def test_curing_duty_son_reset(self):
self.pcdsm.curing_duty_son_reset()
# 测试查看
@allure.step(title="养护职责子管理查看")
def test_curing_duty_son_watch(self):
self.pcdsm.curing_duty_son_watch()
class TestEmployee(unittest.TestCase):
# 初始化
@classmethod
def setUpClass(cls) -> None:
# 获取ApiEmployee对象
cls.api = ApiEmployee()
# 新增员工
@parameterized.expand(read_txt("employee_post.txt"))
def test_01(self, username, mobile, workNumber):
# 调用新增接口
r = self.api.api_post_emp(username, mobile, workNumber)
print("新增员工后的结果为：", r.json())
# 提取user_id
api.user_id = r.json().get("data").get("id")
print("新增的员工id为：", api.user_id)
# 断言
assert_common(self, r)
# # 更新员工
# def test_02(self, username="******"):
# # 调用修改接口
# r = self.api.api_put_emp(username)
# print("更新员工名称结果为: ", r.json())
# # 断言
# assert_common(self, r)
#
# # 查询员工
# def test_03(self):
# # 调用查询接口
# r = self.api.api_get_emp()
# print("查询员工名称结果为：", r.json())
# # 断言
# assert_common(self, r)
# 删除员工
def test_04(self):
# 调用删除接口
r = self.api.api_delete_emp(api.user_id)
print("删除数据结果为：", r.json())
# 断言
assert_common(self, r)
class TestEmployee(unittest.TestCase):
# 初始化
@classmethod
def setUpClass(cls):
# 获取ApiEmployee对象
cls.emp = ApiEmployee()
# 新增员工
@parameterized.expand(read_txt("employee_post.txt"))
def test01_post(self, username, mobile, workNum):
# 调用新增接口
r = self.emp.api_post_employee(username, mobile, workNum)
# 提取user_id
print("添加员工响应结果为:", r.json())
api.user_id = r.json().get("data").get("id")
print("添加员工成功后id值为:", api.user_id)
# 断言
assert_common(self, r)
# 修改员工
def test02_put(self, username="******"):
# 调用更新接口方法
# data={"username":username}
r = self.emp.api_put_employee(username)
print("修改员工响应结果为:", r.json())
# 断言
assert_common(self, r)
# 查询员工
def test03_get(self):
# 调用查询接口
r = self.emp.api_get_employee()
print("查询员工响应结果为: ", r.json())
# 断言
assert_common(self, r)
def test04_delete(self):
# 调用删除员工方法
r = self.emp.api_delete_employee()
print("删除员工响应结果为:", r.json())
# 断言
assert_common(self, r)
class TestDeptManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pum = PageUnitsManage(cls.driver)
cls.pum.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
@allure.step(title="点击部件管理")
def test_units_manage_click(self):
self.pum.units_manage_click()
@parameterized.expand(read_txt("base_info_manage/units_manage.txt"))
@allure.step(title="部件管理输入异常数据新增")
def test_units_manage_insert(self, units_name, sn, remark, desc, success):
self.pum.units_manage_insert(units_name, sn, remark, desc)
if success:
try:
self.pum.page_units_manage_return_click()
except:
self.pum.base_get_image()
# 测试新增、查询、编辑
@allure.step(title="部件管理新增、查询到编辑")
def test_units_manage_edit(self):
self.pum.units_manage_edit(page.public_value, page.public_order_num,
page.public_value, page.public_value)
# 测试查看
@allure.step(title="部件管理查看")
def test_units_manage_watch(self):
self.pum.units_manage_watch()
# 测试重置
@allure.step(title="部件管理重置")
def test_units_manage_reset(self):
self.pum.units_manage_reset()
class TestEmployee(unittest.TestCase):
# 初始化
@classmethod
def setUpClass(cls):
# 获取ApiEmployee对象
cls.api = ApiEmployee()
# 新增员工
@parameterized.expand(read_txt("employee_post.txt"))
def test01_post(self, username, mobile, workNumber):
# 调用新增接口
r = self.api.api_post_employee(username, mobile, workNumber)
print("新增员工后结果为：",r.json())
# 提取 user_di
api.user_id = r.json().get("data").get("id")
print("新增的员工id为：", api.user_id)
# 断言
assert_common(self,r)
# 更新
def test02_put(self, username="******"):
r = self.api.api_put_employee(username)
print("更新员工名称结果为：", r.json())
# 断言
assert_common(self, r)
# 查询
def test03_get(self):
r = self.api.api_get_employee()
print("查询员工名称结果为：", r.json())
# 断言
assert_common(self, r)
# 删除
def test04_delete(self):
# 调用删除接口
r = self.api.api_delete_employee(api.user_id)
print("删除数据结果为：", r.json())
# 断言
assert_common(self,r)
class TestSystemClassManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pscm = PageSystemClassManage(cls.driver)
cls.pscm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 点击系统类别管理
@allure.step(title="点击系统类别管理")
def test_system_class_manage_click(self):
self.pscm.system_class_manage_click()
# 实现新增输入异常数据
@parameterized.expand(read_txt("base_info_manage/system_class.txt"))
@allure.step(title="系统类别管理异常数据新增")
def test_system_class_manage_insert(self, system_class, desc, success):
self.pscm.system_class_manage_insert(system_class, desc)
if success:
try:
self.pscm.page_system_class_manage_return_button()
except:
self.pscm.base_get_image()
# 同时实现新增、查询、编辑
@allure.step(title="系统类别管理新增、查询与编辑")
def test_system_class_manage_edit(self):
self.pscm.system_class_manage_edit(page.public_value,
page.public_value)
# 实现重置
@allure.step(title="系统类别管理重置")
def test_system_class_manage_reset(self):
self.pscm.system_class_manage_reset()
class TestDeptManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pcim = PageCuringInferenceManage(cls.driver)
cls.pcim.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
@allure.step(title="养护结论点击")
def test_curing_inference_manage_click(self):
self.pcim.curing_inference_manage_click()
@parameterized.expand(read_txt("curing_work_manage/curing_inference.txt"))
@allure.step(title="养护结论输入异常数据新增")
def test_curing_inference_manage_insert(self, inference, desc, success):
self.pcim.curing_inference_manage_insert(inference, desc)
if success:
try:
self.pcim.page_curing_inference_manage_return_click()
except:
self.pcim.base_get_image()
# 测试新增、查询、编辑
@allure.step(title="养护结论新增、查询到编辑")
def test_curing_inference_manage_edit(self):
self.pcim.curing_inference_manage_edit(page.public_value,
page.public_value)
# 测试重置
@allure.step(title="养护结论重置")
def test_curing_inference_manage_reset(self):
self.pcim.curing_inference_manage_reset()
class TestSystemClassManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.prcm = PageRepairClassManage(cls.driver)
cls.prcm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
@allure.step(title="点击备件类别管理")
def test_repair_class_manage_click(self):
self.prcm.repair_class_manage_click()
@parameterized.expand(read_txt("base_info_Manage/repair_class.txt"))
@allure.step(title="备件类别管理输入异常数据新增")
def test_repair_class_manage_insert(self, repair_name, desc, success):
self.prcm.repair_class_manage_insert(repair_name, desc)
if success:
try:
self.prcm.page_repair_class_manage_return_button()
except:
self.prcm.base_get_image()
# 测试新增、查询、修改
@allure.step(title="备件类别管理新增、查询到修改")
def test_repair_class_manage_edit(self):
self.prcm.repair_class_manage_edit(page.public_value,
page.public_value)
# 测试重置
@allure.step(title="备件类别管理重置")
def test_repair_class_manage_reset(self):
self.prcm.repair_class_manage_reset()
class TestNumDictManage(unittest.TestCase):
driver = None
@classmethod
def setUpClass(cls) -> None:
cls.driver = GetDriver().get_driver()
cls.pndm = PageNumDictManage(cls.driver)
cls.pndm.system_login()
@classmethod
def tearDownClass(cls) -> None:
GetDriver().quit_driver()
# 测试数字字典管理新增
@parameterized.expand(read_txt("system_manage/system_num_dict.txt"))
@allure.step(title="测试数字字典的异常输入新增")
# @pytest.mark.run(order=1)
def test_num_dict_manage_except_insert(self, desc, type_other, mark_info,
success):
self.pndm.page_num_dict_manage_insert(desc, type_other, mark_info)
if success:
try:
self.pndm.page_num_dict_manage_insert_return_button()
except:
self.pndm.base_get_image()
# 测试数字字典管理新增
@allure.step(title="测试数字字典的正常输入新增")
# @pytest.mark.run(order=2)
def test_num_dict_manage_insert(self):
self.pndm.page_num_dict_manage_insert(page.public_value,
page.public_value,
page.public_value)
# 测试数字字典管理编辑
@allure.step(title="测试数字字典的编辑")
# @pytest.mark.run(order=3)
def test_num_dict_manage_edit(self):
self.pndm.page_num_dict_manage_edit(page.public_value,
page.public_value,
page.public_value)
# 测试数字字典字典项新增
@parameterized.expand(read_txt("system_manage/system_num_dict_tem.txt"))
@allure.step(title="测试数字字典项的异常输入新增")
# @pytest.mark.run(order=4)
def test_num_dict_manage_four_line_nape_insert(self, data, tag, desc,
order, mark_info, success):
self.pndm.page_num_dict_manage_four_line_nape_insert(
data, tag, desc, order, mark_info)
if success:
try:
self.pndm.page_num_dict_manage_four_insert_return_button()
except:
self.pndm.base_get_image()
# 测试数字字典字典项新增
@allure.step(title="输入数字字典项的正常输入新增")
# @pytest.mark.run(order=5)
def test_num_dict_manage_four_line_nape_insert(self):
self.pndm.page_num_dict_manage_four_line_nape_insert(
page.public_value, page.public_value, page.public_value,
page.public_order_num, page.public_value)
# 测试数字字典字典项编辑
@allure.step(title="输入数字字典项的编辑")
# @pytest.mark.run(order=6)
def test_num_dict_manage_four_line_nape_edit(self):
self.pndm.page_num_dict_manage_four_line_nape_edit(
page.public_value, page.public_value, page.public_value,
page.public_order_num, page.public_value)
class Test_official:
# 初始化
def setup_class(self):
# 获取ApiMp对象
self.mp = Api_official()
# 登录
@pytest.mark.parametrize("user", read_txt("Personal_Center.txt"))
def test01_official_login(self, user):
# 调用登录方法
r = self.mp.api_login(user[0], user[1])
# # 提取token
Tools.get_token(r)
# 断言
Tools.official_assert_common(r)
log.info("登录断言成功")
# # 城市北京写字楼首页
def test02_office_bj_index(self):
# 调用北京写字楼首页方法
r = self.mp.api_bj_office_index()
# 断言
Tools.official_assert_common(r)
log.info("北京写字楼首页接口正常")
# 城市杭州写字楼首页
def test03_office_hz_index(self):
# 调用杭州写字楼首页方法
r = self.mp.api_hz_office_index()
# 断言
Tools.official_assert_common(r)
# 南京城市写字楼首页
def test04_office_nj_index(self):
# 调用南京写字楼首页方法
r = self.mp.api_nj_office_index()
# 断言
Tools.official_assert_common(r)
# 上海城市写字楼首页
def test05_office_sh_index(self):
# 调用上海写字楼首页方法
r = self.mp.api_sh_office_index()
# 断言
Tools.official_assert_common(r)
# 成都城市写字楼首页
def test06_office_cd_index(self):
# 调用成都写字楼首页方法
r = self.mp.api_cd_office_index()
# 断言
Tools.official_assert_common(r)
# 青岛城市写字楼首页
def test07_office_qd_index(self):
# 调用青岛写字楼首页方法
r = self.mp.api_qd_office_index()
# 断言
Tools.official_assert_common(r)
# 地区列表
def test08_office_List_of_regions(self):
# 调用地区列表接口
r = self.mp.api_office_List_of_regions()
# 断言
Tools.official_assert_common(r)
# 房源详情
@pytest.mark.parametrize("Listing_details",
read_txt("Listing_details.txt"))
def test09_office_Listing_details(self, Listing_details):
# 调用房源详情页接口
r = self.mp.api_office_Listing_details(Listing_details[0],
Listing_details[1])
# 断言
Tools.official_assert_common(r)
# 区域筛选
@pytest.mark.parametrize("screen", read_txt("screen.txt"))
def test10_office_screen(self, screen):
# 调用区域筛选接口
r = self.mp.api_office_screen(screen[0], screen[1])
# 断言
Tools.official_assert_common(r)
# 地铁筛选
@pytest.mark.parametrize("metro", read_txt("metro.txt"))
def test11_office_Metro_screening(self, metro):
# 调用地铁筛选接口
r = self.mp.api_office_Metro_screening(metro[0], metro[1])
# 断言
Tools.official_assert_common(r)
# 价格筛选url
@pytest.mark.parametrize("price", read_txt("price.txt"))
def test12_office_Price_screening(self, price):
# 调用价格筛选接口
r = self.mp.api_office_Price_screening(price)
# 有问题
# 断言
Tools.official_assert_common(r)
# 面积筛选url
def test13_office_Area_screening(self):
# 调用面积筛选接口
r = self.mp.api_office_Area_screening(buildarea=(0, 500))
# 断言
Tools.official_assert_common(r)
# 更多筛选接口
def test14_office_More_screening(self):
# 调用更多筛选接口
r = self.mp.api_office_More_screening(tag=(1, 2, 3, 4, 5, 6, 7, 8, 9,
10),
decoratetype=(1, 2, 3, 4, 5))
# 断言
Tools.official_assert_common(r)
# 排序筛选接口
def test15_office_Sort_filter(self):
# 调用排序筛选接口
r = self.mp.api_office_Sort_filter(psort=0)
# 断言
Tools.official_assert_common(r)
# 关键词搜索url
@pytest.mark.parametrize("key_word", read_txt("Personal_Center.txt"))
def test16_office_search(self, key_word):
# 调用关键词搜索接口
r = self.mp.api_office_search(keyword=key_word[0])
Tools.official_assert_common(r)
print(r.json())
# 北京新房首页
@pytest.mark.parametrize("cityid", read_txt("cityid.txt"))
def test17_newhouse_bj_index(self, cityid):
# 调用北京城市首页接口
r = self.mp.api_newhouse_bj_index(cityid=cityid)
# 断言
Tools.official_assert_common(r, msg="", status=200)
#
# 杭州新房首页
def test18_newhouse_hz_index(self):
# 调用杭州城市新房首页接口
r = self.mp.api_newhouse_hz_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 苏州新房首页
def test19_newhosue_sz_index(self):
# 调用苏州新房首页接口
r = self.mp.api_newhouse_sz_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 太原新房首页
def test20_newhosue_ty_index(self):
# 调用太原新房首页接口
r = self.mp.api_newhouse_ty_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 天津新房首页
def test21_newhouse_tj_index(self):
# 调用天津新房首页接口
r = self.mp.api_newhouse_tj_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 南京新房首页
def test22_newhouse_nj_index(self):
# 调用南京新房首页接口
r = self.mp.api_newhouse_nj_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 上海新房首页
def test23_newhosue_sh_index(self):
# 调用上海新房首页接口
r = self.mp.api_newhouse_sh_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 成都新房首页
def test24_newhouse_cd_index(self):
# 调用成都新房首页接口
r = self.mp.api_newhouse_cd_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 南宁新房首页
def test25_newhouse_nn_index(self):
# 调用南宁新房首页接口
r = self.mp.api_newhouse_nn_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 郑州新房首页
def test26_newhouse_zz_index(self):
# 调用郑州新房首页接口
r = self.mp.api_newhouse_zz_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 无锡新房首页
def test25_newhouse_cd_index(self):
# 调用无锡新房首页接口
r = self.mp.api_newhouse_cd_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 武汉新房首页
def test26_newhouse_wh_index(self):
# 调用武汉新房首页接口
r = self.mp.api_newhouse_wh_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 青岛新房首页
def test27_newhouse_qd_index(self):
# 调用成都新房首页接口
r = self.mp.api_newhosue_qd_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 长沙新房首页
def test28_newhouse_cs_index(self):
# 调用长沙新房首页接口
r = self.mp.api_newhouse_cs_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 南昌新房首页
def test29_newhouse_nc_index(self):
# 调用南昌新房首页接口
r = self.mp.api_newhouse_nc_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 常州新房首页
def test30_newhouse_cz_index(self):
# 调用南昌新房首页接口
r = self.mp.api_newhouse_cz_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 东莞新房首页
def test31_newhouse_dg_index(self):
# 调用东莞新房首页接口
r = self.mp.api_newhouse_dg_index()
# 断言
Tools.official_assert_common(r, msg="成功", status=200)
# 发送邮件
def test32_senmail(self):
Tools.send_mail()
def get_data():
# return [('13888888888', '123456', '8888'), ('13800008888', '123456', '8888'), ('13888888888', '12345', '8888')]
arrs = []
for arr in read_txt():
arrs.append(tuple(arr.strip().split(",")))
return (arrs[1::])
from tools.read_txt import read_txt
"""公共url定义"""
HOST = "http://ttapi.research.itcast.cn"
"""公共headers"""
headers = {"Content-Type": "application/json"}
# 发布文章id
article_id = None
# 文章title
title = read_txt("mp_article.txt")[0][0]
# 频道id
channel_id = read_txt("mp_article.txt")[0][2]
# 文章频道 id为7 的频道为数据库
channel = read_txt("mp_article.txt")[0][3]
def get_data():
arrs = []
for data in read_txt("login.txt"):
arrs.append(tuple(data.strip().split(',')))
# 切片忽略首行
return arrs[1:]
