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:]