python_pytest-软件测试UI自动化全集【3】之整个业务流程代码解析

python_pytest-软件测试UI自动化全集【3】之整个业务流程代码解析

相关博文：UI自动化【1】
UI自动化【2】

其实编写UI自动代码也是一层层封装，先写出自定义方法的封装—创建引用自定义方法的基类—页面类又继承基类，使用基类的基本方法—执行脚本（测试用例）的入口则直接引用到页面类业务层的方法。以下代码详解。（涉及代码的具体业务功能可以参考e签宝：e签宝）

直接的.py文件

• 自定义方法utils.py（编写获取浏览器驱动get_driver的方法、获取弹窗的信息get_mes的方法等）
  利用@calssmethod装饰器可以不需要实例化的功能，直接类名.方法名()来全局调用。

  import json
  import time
  
  from selenium import webdriver
  from selenium.webdriver.common.by import By
  from selenium.webdriver.support import expected_conditions
  from selenium.webdriver.support.wait import WebDriverWait
  
  
  class UtilsDriver:
      _driver=None
      @classmethod
      def get_driver(cls):
          # 定义获取浏览器驱动的方法
          if cls._driver is None:#只需要driver驱动启动一次，所以增加这个判断
              cls._driver=webdriver.Chrome()#谷歌
              # cls._driver=webdriver.Firefox()#火狐
              cls._driver.maximize_window()#窗口最大化
              cls._driver.implicitly_wait(5)
              #设置超时时间5s，它的作用的全局的，也就是在一个脚本中只需要使用一次，作用范围是针对整个webdriver对象实例。在每次进行 find_element时起作用，implicitly_wait()会将一个超时的时间阀值传递给 WebDriver，在findelement或者findelements的时候，首先去找 web element，如果没有找到，判断时间否超超过 implicitlyWait()传递进来的阀值，如果没有超过，则再次找这个element，直到找到 element 或者时间超过最大阀值。    
              cls._driver.get("https://pc.****.com/#/login")#输入要测试的网站
              time.sleep(1)
               #直接强制等待设置的秒数，静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”,当睡眠时间到期，则返回到可运行状态。
          return cls._driver
  
      @classmethod
      def my_driver(cls):
          if cls._driver is None:
              cls._driver = webdriver.Chrome()  # 谷歌
              # cls._driver=webdriver.Firefox()#火狐
              time.sleep(1)          
          return cls._driver
  
  
      @classmethod
      def quit_driver(cls):
          if cls._driver is not None:
              cls.get_driver().quit()
              cls._driver = None
      # @classmethod
      # def Wait_ele(cls,driver,time,pat):
      #     return WebDriverWait(driver, time, 1).until(lambda x: x.find_element(By.XPATH,pat))
  
  
      @classmethod
      def get_mes(cls, xpath):
          #获取指定路径的元素的文本text信息
          return UtilsDriver.get_driver().find_element(By.XPATH, xpath).text
  
      @classmethod
      
      def get_mes_wait(cls, xpath):
          #带显性等待的获取弹窗元素
          wait = WebDriverWait(UtilsDriver.get_driver(), 10, 1)
          element = wait.until(lambda x:x.find_element(By.XPATH,xpath))
          return element
  
      @classmethod
      def get_mes_s(cls, xpath):
          '''
  
          :param xpath: 元素的路径
          :return:find_elements返回的是以元素列表，不可以直接取text,只能用for循环历遍各个元素并读取文本值
          '''
          eles=UtilsDriver.get_driver().find_elements(By.XPATH, xpath)
          alist=[]
          for ele in eles:
              ele_mes = ele.text
              alist.append(ele_mes)
          print(alist)
          return alist
  
      @classmethod
      def get_element_utils_wait(cls, location):#page页对象层的基类，带显性等待的获取元素方法（相较于隐性等待，这个显性等待要明确等待条件和等待上限。比如隐性等待，只要元素存在，可找到就可以，但显性等待，我要明确条件是我的元素可见。而元素存在，并不一定是元素可见。显性等待的场景：操作引起了页面的变化，而接下来要操作变化的元素的时候，就需要使用显性等待）
          wait = WebDriverWait(UtilsDriver.get_driver(), 10, 1)
          element_wait = wait.until(lambda x: x.find_element(By.XPATH, location))
          return element_wait
  
      @classmethod
      def get_elements(self, xpath):
          #获取多个元素elements的方法
          """
          :param xpath: 表示元素定位的路径
          :return: 返回找到的元素
          """
          return UtilsDriver.get_driver().find_elements(By.XPATH, xpath)
  
      @classmethod
      def get_attribute(cls, xpath, attribute):
          '''
          以元素的属性值来断言，断言前必须延迟2s
          :param xpath: 找到元素的路径，只取到前面的标签，然后根据标签中的元素名来判断属性值对不对
          :param attribute: 标签中的元素名
          :return: 属性值
          '''
          return UtilsDriver.get_driver().find_element(By.XPATH, xpath).get_attribute(attribute)
  
      @classmethod
      def get_alert(cls):
          #获取报错弹窗alert_is_present的方法
          WebDriverWait(cls.driver, timeout=10, poll_frequency=0.5).until(expected_conditions.alert_is_present())
          #wait.until(expected_conditions.alert_is_present())
          alert = cls.driver.switch_to.alert
          return alert.text
  
      @classmethod
      def get_case_data(cls, filename):
          #用于获取指定data文件中的数据
          with open(filename, encoding="utf-8") as f:
              case_data = json.load(f)
          list_case_data = []#设置一个空列表，来添加读取的data文件中的json值
          for case in case_data:
              for x in case.values():
                  case_tuple = x.values()#取每组参数的参数值
                  list_case_data.append(tuple(case_tuple))#将每组参数值都元组化，然后逐个添加到列表中
          print(list_case_data)
          return list_case_data
  

新建python package

package主要用于存放代码的目录，其中包括一组模块和一个__init__.py文件。目录下具有init.py文件，这样可以通过from…import的方式进行.py文件的导入。

基类base

编写后期大量被继承的类，如UI自动化中的get_element-获取元素的方法、显式等待方法等

from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait

from utils import UtilsDriver
class BasePage:
#page页对象层的基类，后面继承BasePage的类就有对应以下的方法
    def __init__(self):
        print("基类的~BasePage")
        self.driver=UtilsDriver.get_driver()#实例化获取浏览器驱动的方法，get_driver方法的引用就有隐形等待

    def get_element(self, location):#显性等待获取页面元素的方法
        wait = WebDriverWait(self.driver,10,1)
        element = wait.until(lambda x:x.find_element(*location))
        return element

    def get_elements(self,xpath):#获取的元素不是单个
        """
        :param xpath: 表示元素定位的路径
        :return: 返回找到的元素
        """
        return self.driver.find_elements(By.XPATH,xpath)

    def get_element_wait(self, location):
        #page页对象层的基类，显式等待
        # （定义等待条件，当条件发生时才执行后续代码。程序会轮询查看条件是否发生（默认 10 秒），
        # 如果条件成立则执行下一步，否则继续等待，直到超过设置的最长时间，程序抛出异常。）
       
        wait = WebDriverWait(self.driver, 10, 1)
        element_wait = wait.until(lambda x: x.find_element(By.XPATH, location))
        return element_wait

    def get_element_1(self,xpath):
        """
        :param xpath: 表示元素定位的路径
        :return: 返回找到的元素
        """
        return self.driver.find_element(By.XPATH, xpath)

页面类

page-登录功能页面代码page_login.py

'''
登录界面
'''
import time
from selenium.webdriver.common.by import By
from utils import UtilsDriver
from base.base_page import BasePage
import ddddocr
from pykeyboard import PyKeyboard
from selenium.webdriver import ActionChains
from selenium.webdriver.common.keys import Keys


class PageLogin(BasePage):#对象库层
    def __init__(self):#__init__ 方法是 Python 中面向对象编程中类的特殊方法，也称为构造方法，当创建一个类的实例时，__init__ 方法会自动调用。
        super().__init__()#改写构造方法
        #以下是登录功能操作是需要点击的元素路径
        self.password_login_bt2=By.XPATH,"//div[text()='密码登录']"
        self.username=By.XPATH,"//*/input[@placeholder='请输入手机号']"
        self.password2=By.XPATH,"//*/div[@class='password-box']"
        self.choose=By.XPATH,"//*/span[@class='el-checkbox__inner']"
        self.login_bt=By.XPATH,"//*[text()='登录']"
        self.code=By.XPATH,"(//div/div/img)[5]"#识别图像验证码的图
        self.code_input=By.XPATH,"//*/input[@placeholder='图形验证码']"#识别图形验证码的输入框
        #识别是否有弹出框,有的话,重新点验证码登录,再点密码登录
        self.alert=By.XPATH,"//*/div[@role='alert']"#判断有弹窗
        self.code_login=By.XPATH,"//*[text()='验证码登录']"#验证码登录元素
        self.pwd_login=By.XPATH,"//*[text()='密码登录']"#密码登录元素

# 以下为通过各个元素路径找到各人元素的方法
    def find_password_login_bt2(self):
        return self.get_element(self.password_login_bt2)

    def find_password2(self):
        return self.get_element(self.password2)

    def find_username(self):
        return self.get_element(self.username)

    def find_choose(self):
        return self.get_element(self.choose)

    def find_login_bt(self):
        return self.get_element(self.login_bt)

    def find_code(self):
        return self.get_element(self.code)
    
    def find_code_input(self):
        return self.get_element(self.code_input)

    def find_alert(self):#找是否有弹窗
        return self.get_element(self.alert)
    
    def find_code_login(self):#找验证码登陆
        return self.get_element(self.code_login)
    
    def find_pwd_login(self):#找密码登录
        return self.get_element(self.pwd_login)

    def find_mes_code_login_input_box(self):
        return self.get_element_wait("//input[@placeholder='请输入手机号']")

    def find_img_code_input_box(self):
        return self.get_element_wait("//input[@placeholder='图形验证码']")

    def find_get_code_bt(self):
        return self.get_element_wait("//button/span[text()='获取验证码']")

    def find_mes_code_input_box(self):
        return self.get_element_wait("//input[@placeholder='验证码']")


#以下为对上面对象层找到的元素进行操作的方法
class HandleLogin:
    def __init__(self):
        self.driver = UtilsDriver.get_driver()
        self.login_page=PageLogin()
        self.k = PyKeyboard()#实例化键盘对象
        self.keys = Keys()
        self.ac = ActionChains(self.driver)

    def click_find_password_login_bt2(self):#找到密码登录
        self.login_page.find_password_login_bt2().click()
        time.sleep(1)

    def input_username(self, username):#输入用户名
        self.login_page.find_username().clear()
        time.sleep(1)
        self.login_page.find_username().send_keys(username)

    def input_password2(self, password2):
        self.login_page.find_password2().click()
        for i in range(10):
            self.login_page.find_password2().send_keys(Keys.BACK_SPACE)#无法使用clear，只能点10次BACK_SPACE
        self.login_page.find_password2().send_keys(password2)

    def click_choose_bt(self):
        self.login_page.find_choose().click()
        
    def click_login_bt(self):
        self.login_page.find_login_bt().click()
        

    def input_code(self):#识别图像验证码
        ocr=ddddocr.DdddOcr()#实例化ddddocr
        code_see=ocr.classification(self.login_page.find_code().screenshot_as_png)#识别出验证码
        self.login_page.find_code_input().clear()
        self.login_page.find_code_input().send_keys(code_see)
        
    def login_fail(self):#登录失败,有弹窗,点验证码登录,再点密码登录
        if self.login_page.find_alert:
            self.login_page.find_code_login().click()
            time.sleep(1)
            self.login_page.find_pwd_login().click()
            time.sleep(1)

    def click_mes_code_login_input_phone_box(self,phone):
        self.login_page.find_mes_code_login_input_box().click()
        self.login_page.find_mes_code_login_input_box().clear()
        self.login_page.find_mes_code_login_input_box().send_keys(phone)

    def input_img_code(self):#识别图像验证码
        ocr=ddddocr.DdddOcr()#实例化ddddocr
        code_see=ocr.classification(self.login_page.find_img_code_input_box().screenshot_as_png)#识别出验证码
        self.login_page.find_code_input().clear()
        self.login_page.find_code_input().send_keys(code_see)

    def click_get_code_bt(self):
        self.login_page.find_get_code_bt().click()

    def clic_mes_code_input_box(self,mes_code="123456"):
        self.login_page.find_mes_code_input_box().click()
        self.login_page.find_mes_code_input_box().clear()
        self.login_page.find_mes_code_input_box().send_keys(mes_code)
        
#以下为组合上面对元素操作的业务流程
class LoginProxy:
    def __init__(self):
        self.handle_login=HandleLogin()

    def login(self,username,password2):
        # self.handle_login.click_find_password_login_bt()
        time.sleep(1)
        self.handle_login.click_find_password_login_bt2()
        print("找到用密码进行登录的选项1")
        self.handle_login.input_username(username)
        print("输入用户名2")
        self.handle_login.input_password2(password2)
        print("输入密码3")
        time.sleep(1)
        self.handle_login.input_code()
        print("输入验证码4")
        self.handle_login.click_choose_bt()
        print("勾选协议5")

        try:
            self.handle_login.click_login_bt()
            print("点击登录,暂停3秒")
            time.sleep(3)
            if str(UtilsDriver.get_mes("//button/span")) == "登录":
                time.sleep(1)

                self.handle_login.input_code()
                print("重新输入验证码")
                self.handle_login.click_login_bt()
                print("重新点击登录")
                time.sleep(2)
                # raise Exception("验证码出错，请重新输入")
                if str(UtilsDriver.get_mes("//button/span")) == "登录":
                    time.sleep(1)

                    self.handle_login.input_code()
                    print("重新输入验证码")
                    self.handle_login.click_login_bt()
                    print("重新点击登录")
                    # raise Exception("验证码第二次出错，请重新输入")
        except:
            time.sleep(1)
        else:
            print("第一次登录就成功")
        finally:
            print("执行完登录的代码了")

    def login_wrong_pwd(self,username,password2):#登录反向流程，错误密码登录
        time.sleep(1)
        self.handle_login.click_find_password_login_bt2()
        print("找到用密码进行登录的选项1")
        self.handle_login.input_username(username)
        print("输入用户名2")
        self.handle_login.input_password2(password2)
        print("输入密码3")
        time.sleep(1)
        self.handle_login.input_code()
        print("输入验证码4")
        self.handle_login.click_choose_bt()
        print("勾选协议5")
        self.handle_login.click_login_bt()
        print("重新点击登录6")


    def login_by_mes_code(self,username):#正向登录流程，用短信验证码登录
        time.sleep(1)
        self.handle_login.input_username(username)
        print("输入手机号")
        self.handle_login.input_code()
        print("输入验证码")
        time.sleep(1)
        self.handle_login.click_get_code_bt()
        print("获取验证码")
        time.sleep(1)
        self.handle_login.clic_mes_code_input_box()
        print("输入验证码")
        time.sleep(1)
        self.handle_login.click_choose_bt()
        print("勾选协议")

        try:
            self.handle_login.click_login_bt()
            print("点击登录,暂停3秒")
            time.sleep(3)
            if str(UtilsDriver.get_mes("(//button/span)[2]")) == "登录":
                time.sleep(1)

                self.handle_login.input_code()
                print("重新输入验证码")
                self.handle_login.click_login_bt()
                print("重新点击登录")
                time.sleep(2)
                # raise Exception("验证码出错，请重新输入")
                if str(UtilsDriver.get_mes("(//button/span)[2]")) == "登录":
                    time.sleep(1)

                    self.handle_login.input_code()
                    print("重新输入验证码")
                    self.handle_login.click_login_bt()
                    print("重新点击登录")
                    # raise Exception("验证码第二次出错，请重新输入")
        except:
                # Exception as result:
            # print(result)
            time.sleep(1)
        else:
            print("第一次登录就成功")
        finally:
            print("执行完登录的代码了")

page-退出登录功能login_out.py

"""
退出登录
"""
import time
from selenium.webdriver.common.by import By
from page.page_login import LoginProxy

from utils import UtilsDriver
from base.base_page import BasePage
# from selenium.webdriver import ActionChains
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains

# 对象层

class PageCompanyMes(BasePage):

    def __init__(self):
        super(PageCompanyMes, self).__init__()
# 对象层的私有属性，改写基类的私有属性，基类有#get_driver方法的引用就有隐形等待
    def find_head_png(self):
        return self.get_element_wait("//img[@class='avatar-img']")  # 找到头像

    def find_login_out(self):
        return self.get_element_wait("//span[text()='退出登录']")
#操作层
class HandleCompanyMes():

    def __init__(self):
        self.page_company_mes = PageCompanyMes()
        

    def click_head_png(self):
        self.page_company_mes.find_head_png().click()

    def click_login_out(self):
        self.page_company_mes.find_login_out().click()

#业务层
class ProxyCompanyMes():

    def __init__(self):
        self.handle_company_mes = HandleCompanyMes()
        self.login_proxy = LoginProxy()

        def LOGIN_OUT_LOGIN_AGAIN(self,phone="13800138002"):
            '''
    退出当前账号，进入13800138002账号
    :return:
    '''
            self.handle_company_mes.click_head_png()
            print("点击头像")
            time.sleep(1)
            self.handle_company_mes.click_login_out()
            print("点击退出")
            time.sleep(1)
            self.login_proxy.login(phone, "***密码")
            print("重新登录13800138002：setup登录")
            time.sleep(1)

page-发起业务合同并签署功能page_handle_contract.py

（该页面是电子签约系统的主要功能，用例执行的前提是登录，则会使用到page_login.py）

'''
经办合同，按用例详细输入
pytest -v -s test_handle_contract.py
'''
import time
from utils import UtilsDriver
from base.base_page import BasePage
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains

#对象层
class PageHandleContract(BasePage):
    def __init__(self):
        super(PageHandleContract, self).__init__()
        #对象层的私有属性

    #经办合同，直接发起的对象层
    def find_handle_contract(self):#点击经办合同
        return self.get_element_1("//div[text()=' 经办合同 ']")

    def find_first_company(self):#点个人后的第一个公司
        return self.get_element_1("//div[@class='el-tabs__item is-top is-active']")

    def find_first_company2(self):
        return self.get_element_1("//div[text()='中广核医疗科技（绵阳）有限公司']")

    def find_initiate_contract_signing(self):#点击发起合同签署
        return self.get_element_1("//span[text()=' 发起合同签署 ']")

    def find_initiate_directly(self):#点击直接发起
        return self.get_element_1("//li[text()='直接发起']")

    def find_task_name(self):#找到任务名称
        return self.get_element_1("//input[@placeholder='请输入任务名称']")

    def find_verify(self):#找审批模版
        return self.get_element_1("//input[@placeholder='请选择']")

    def find_first_verify(self):#选择第一个审批模版“审批一人”
        return self.get_element_1("//span[contains(text(),'审批一人')]")

    def find_upload_files(self):#找到上传合同文件按钮
        return self.get_element_1("//input[@accept='.pdf,.PDF,.doc,.docx']")

    def find_upload_attachment(self):#上传附件按钮
        return self.get_element_1("(//input[@class='el-upload__input'])[2]")

    def find_add_participants1(self):#添加参与者1
        return self.get_element_1("(//span[text()='添加企业'])[1]")

    def find_company_input_box(self):#企业输入框
        return self.get_element_1("//input[@placeholder='请输入企业名称']")

    def find_name_input_box1(self):#姓名输入框
        return self.get_element_1("//input[@placeholder='请输入真实姓名']")

    def find_phone_input_box1(self):#添加手机号
        return self.get_element_1("//input[@placeholder='请输入手机号']")

    def find_add_participants2(self):#添加参与者2_个人
        return self.get_element_1("(//span[text()='添加个人'])[1]")

    def find_name_input_box2(self):#添加个人姓名
        return self.get_element_1("(//input[@placeholder='请输入真实姓名'])[2]")

    def find_phone_input_box2(self):#添加个人手机
        return self.get_element_1("(//input[@placeholder='请输入手机号'])[2]")

    def find_company_cc(self):
        return self.get_element_1("(//span[contains(text(),'添加企业')])[2]")

    def find_company_input_box2(self):
        return self.get_element_1("(//input[@placeholder='请输入企业名称'])[3]")#找到抄送者的企业参名

    def find_name_input_box3(self):
        return self.get_element_1("(//input[@placeholder='请输入真实姓名'])[3]")#找到抄送者的企业姓名输入框

    def find_phone_input_box_cc(self):
        return self.get_element_1("//input[@placeholder='请输入手机号码']")#cc的企业输入手机号码

    def find_initiate_directly_bt(self):
        return self.get_element_1("//span[text()='直接发起']")#直接发起按钮

    #审批合同的对象层
    def find_verify_administer(self):#点审批管理
        return self.get_element_1("//div[contains(text(),' 审批管理 ')]")

    def find_verify_by_me(self):#点待我处理
        return self.get_element_1("(//span[contains(text(),'待我审批')])[1]")

    def find_agree_bt(self):
        return self.get_element_1("(//span[text()='同意'])[1]")#第一个同意按钮

    def find_confirm_bt(self):
        return self.get_element_1("//span[contains(text(),'确认')]")#点击确认按钮


    #经办合同-待我处理

    def find_handle_by_me(self):
        return self.get_element_1("//span[text()='待我处理']")#点击经办合同的待我处理

    def find_next_bt(self):
        return self.get_element_1("//button[@class='btn-next']")#点击下一页,如果不能点，则多一个属性@disabled="disabled"

    def find_contracts(self):
        return self.get_elements("//tr[@class='el-table__row']/td[2]/div")#找到当前页的所有合同，返回一个列表
        #return self.get_element_1("//tr[@class='el-table__row']/td[2]")#找到当前页的所有合同，返回一个列表

    def find_contract(self):
        return self.get_element_1("//tr[@class='el-table__row']/td[2]")

    def find_num_input_box(self):
        return self.get_element_1("//input[@placeholder='请输入编号']")#找到编号输入框

    def find_search_bt(self):
        return self.get_element_1("//span[text()='查询']")#找到查询按钮

    def find_handle_by_me_sign(self):
        return self.get_element_1("(//button/span[text()='签署'])[1]")#找到待我处理的签署按钮

    def find_first_seal(self):
        return self.get_element_1("(//div/div/img)[4]")#找到第一个印章

    def find_submit_sign(self):
        return self.get_element_1("//button/span[contains(text(),' 提交签署 ')]")#找到提交签署

    def find_get_ver_code(self):
        return self.get_element_1("//button/span[contains(text(),'获取验证码')]")#找到获取验证码

    def find_msm_input_box(self):
        return self.get_element_1("(//input[@class='el-input__inner'])[3]")#找到短信输入框

    def find_code_confirm_bt(self):
        return self.get_element_1("//button/span[contains(text(),'确认')]")#找到短信确认按钮

#操作层

class HandleHandleContract():
    def __init__(self):
        self.page_handlecontract=PageHandleContract()#对象层实例化

    def click_handle_contract(self):
        self.page_handlecontract.find_handle_contract().click()#点击经办合同

    def click_first_compay(self):
        self.page_handlecontract.find_first_company2().click()#点击第一个企业

    def click_initiate_contract_signing(self):
        self.page_handlecontract.find_initiate_contract_signing().click()#点击发起合同签署

    def click_initiate_directly(self):
        self.page_handlecontract.find_initiate_directly().click()#点击直接发起

    def send_keys_task_name(self,task_name):
        self.page_handlecontract.find_task_name().send_keys(task_name)#输入任务名称

    def click_verify(self):
        self.page_handlecontract.find_verify().click()
        self.page_handlecontract.find_first_verify().click()

    def send_keys_upload_files(self,file_contract):
        self.page_handlecontract.find_upload_files().send_keys(file_contract)
        #点击上传文件按钮

    def send_keys_upload_attachment(self,attachment):
        self.page_handlecontract.find_upload_attachment().send_keys(attachment)#点击上传附件

    def click_add_participants1(self):
        self.page_handlecontract.find_add_participants1().click()#点击添加参与者

    def send_keys_company_input_box(self,company_name):
        self.page_handlecontract.find_company_input_box().send_keys(company_name)#点击企业输入框

    def send_keys_name_input_box1(self,name1):
        self.page_handlecontract.find_name_input_box1().send_keys(name1)#企业参与者的经办人姓名

    def send_keys_phone_input_box1(self,phone1):#企业参与者的经办人手机
        self.page_handlecontract.find_phone_input_box1().send_keys(phone1)

    def click_add_participants2(self):#点击添加参与者2_个人
        self.page_handlecontract.find_add_participants2().click()

    def send_keys_name_input_box2(self,name2):#乙方姓名
        self.page_handlecontract.find_name_input_box2().send_keys(name2)

    def send_keys_phone_input_box2(self,phone2):#乙方手机
        self.page_handlecontract.find_phone_input_box2().send_keys(phone2)

    def click_company_cc(self):#点击添加企业抄送者
        self.page_handlecontract.find_company_cc().click()

    def send_keys_company_input_box_cc(self,cc_company):#输入抄送者企业名
        self.page_handlecontract.find_company_input_box2().send_keys(cc_company)

    def send_keys_company_name_input_box_cc(self,cc_company_name):#输入企业抄送者经办人姓名
        self.page_handlecontract.find_name_input_box3().send_keys(cc_company_name)

    def send_keys_company_phone_input_box_cc(self,cc_company_phone):#输入企业抄送者的手机号
        self.page_handlecontract.find_phone_input_box_cc().send_keys(cc_company_phone)

    def click_initiate_directly_bt(self):#点击直接发起按钮
        self.page_handlecontract.find_initiate_directly_bt().click()

    # 审批合同的操作层
    def click_verify_administer(self):#点击审批管理
        self.page_handlecontract.find_verify_administer().click()

    def click_verify_by_me(self):#点击待我处理
        self.page_handlecontract.find_verify_by_me().click()

    def click_agree_bt(self):#点击同意按钮
        self.page_handlecontract.find_agree_bt().click()

    def click_comfirm_bt(self):#点击确认按钮
        self.page_handlecontract.find_confirm_bt().click()

    #经办合同-待我处理
    def click_handle_by_me(self):
        self.page_handlecontract.find_handle_by_me().click()#点待我处理

    def click_next_bt(self):
        self.page_handlecontract.find_next_bt().click()#点下一页

    def click_num_input_box(self):
        self.page_handlecontract.find_num_input_box().click()
        print("点击编号输入框")
        self.page_handlecontract.find_num_input_box().clear()
        print("清空编号输入框")


    def click_search_bt(self):
        self.page_handlecontract.find_search_bt().click()#点搜索

    def click_handle_by_me_sign(self):
        self.page_handlecontract.find_handle_by_me_sign().click()#点击签署按钮

    def drag_and_drop_seal(self):
        source = self.page_handlecontract.find_first_seal()#拖拽第一个印章
        action = ActionChains(UtilsDriver.get_driver())
        print(source)
        action.drag_and_drop_by_offset(source, -400, 0).perform()
        time.sleep(3)
        
    def click_submit_sign(self):
        self.page_handlecontract.find_submit_sign().click()#点击提交签署

    def click_get_ver_code(self):
        self.page_handlecontract.find_get_ver_code().click()#点击获取验证码

    def send_keys_msm_input_box(self, msm_code):
        self.page_handlecontract.find_msm_input_box().send_keys(msm_code)#输入短信验证码

    def click_code_confirm_bt(self):
        #self.page_handlecontract.find_code_confirm_bt().click()#确认短信按钮
        self.page_handlecontract.find_code_confirm_bt().send_keys(Keys.SPACE)


#业务层

class ProxyHandleContract():
    def __init__(self):
        self.handle_handlecontract=HandleHandleContract()#操作层实例化
        self.page_handlecontract = PageHandleContract()  # 对象层实例化

    def CONTRACT_INITIATED_DIRECTLY_1(self,task_name,file_contract,attachment,company_name,name1,phone1,name2,phone2,cc_company,cc_company_name,cc_company_phone):
        '''

        :param task_name: 任务名称
        :param file_contract: 合同
        :param attachment: 附件
        :param company_name: 企业参与者一公司名称
        :param name1: 企业经办人姓名
        :param phone1: 企业经办人手机号
        :param name2: 个人参与者姓名
        :param phone2: 个人参与者手机号
        :param cc_company: 抄送的公司
        :param cc_company_name: 抄送的公司经办人
        :param cc_company_phone: 企业经办人手机号
        :return: 业务流程
        '''
        self.handle_handlecontract.click_handle_contract()
        print("点击导航栏经办合同")
        time.sleep(2)
        self.handle_handlecontract.click_first_compay()
        print("点击第一个企业")
        self.handle_handlecontract.click_initiate_contract_signing()
        print("点击发起合同签署")
        time.sleep(1)
        self.handle_handlecontract.click_initiate_directly()
        print("点击发起合同签署的直接发起")
        self.handle_handlecontract.send_keys_task_name(task_name)
        print("输入任务名称")
        self.handle_handlecontract.click_verify()
        print("选择第一个审批流")
        self.handle_handlecontract.send_keys_upload_files(file_contract)
        print("上传文件按钮")
        time.sleep(3)
        self.handle_handlecontract.send_keys_upload_attachment(attachment)
        print("上传附件")
        self.handle_handlecontract.click_add_participants1()
        print("添加企业参与者1")
        self.handle_handlecontract.send_keys_company_input_box(company_name)
        print("输入企业名称")
        self.handle_handlecontract.send_keys_name_input_box1(name1)
        print("输入企业经办人姓名")
        self.handle_handlecontract.send_keys_phone_input_box1(phone1)
        print("输入企业经办人手机号")
        self.handle_handlecontract.click_add_participants2()
        print("添加参与者2_个人")
        self.handle_handlecontract.send_keys_name_input_box2(name2)
        print("输入个人姓名")
        self.handle_handlecontract.send_keys_phone_input_box2(phone2)
        print("输入个人手机")
        self.handle_handlecontract.click_company_cc()
        print("点击添加企业参与者")
        self.handle_handlecontract.send_keys_company_input_box_cc(cc_company)
        print("输入抄送者的企业名称")
        self.handle_handlecontract.send_keys_company_name_input_box_cc(cc_company_name)
        print("输入企业经办人")
        self.handle_handlecontract.send_keys_company_phone_input_box_cc(cc_company_phone)
        print("输入企业手机号")
        self.handle_handlecontract.click_initiate_directly_bt()
        print("点击直接发起按钮")


    def VERIFY_ADMINISTER_1(self):
        self.handle_handlecontract.click_verify_administer()
        print("点击审批管理")
        self.handle_handlecontract.click_first_compay()
        print("点击第一个企业")
        self.handle_handlecontract.click_verify_by_me()
        print("点击合同审批的待我审批")
        self.handle_handlecontract.click_agree_bt()
        print("点击同意审批")
        time.sleep(2)
        self.handle_handlecontract.click_comfirm_bt()
        # self.handle_handlecontract.get_alert()

    def HANDLE_BY_ME(self, msm_code):
        '''
        经办合同的待我处理
        :param msm_code: 短信验证码
        :return:
        '''

        self.handle_handlecontract.click_handle_contract()
        print("点击导航栏经办合同")
        self.handle_handlecontract.click_first_compay()
        print("点击第一个企业")
        self.handle_handlecontract.click_handle_by_me()
        print("点击经办合同的待我处理")

        #contracts = self.page_handlecontract.find_contracts()#元素的列表
        #print(contracts)
        #print(contracts[0].text)
        first_contract = self.page_handlecontract.find_contract()
        first_contract_text = first_contract.text
        print("第一个合同编号为：" + str(first_contract_text))
        self.handle_handlecontract.click_num_input_box()
        self.page_handlecontract.find_num_input_box().send_keys(first_contract_text)
        print("输入框输入第一个合同编号")
        self.handle_handlecontract.click_search_bt()
        print("点搜索")
        time.sleep(1)
        self.handle_handlecontract.click_handle_by_me_sign()#点击签署按钮
        print("点签署,time.sleep10s~~~")
        time.sleep(10)
        self.handle_handlecontract.drag_and_drop_seal()#拖拽印章
        print("拖拽印章")
        self.handle_handlecontract.click_submit_sign()#提交签署
        print("提交签署")
        time.sleep(1)
        self.handle_handlecontract.click_get_ver_code()#点击获取验证码
        print("点击获取验证码")
        time.sleep(1)
        self.handle_handlecontract.send_keys_msm_input_box(msm_code)
        print("输入短信验证码")
        self.handle_handlecontract.click_code_confirm_bt()
        print("点击确认按钮")
        self.handle_handlecontract.click_code_confirm_bt()
        print("点击确认按钮2")

执行的脚本

test_handle_contract.py，则主要业务功能的整个执行流程。

会用到上面页面类的三个页面中的业务层。

'''
经办合同模块-直接发起
'''

import time
import datetime
from random import randint
import os
import sys

import allure
#找出当前目录
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
import pytest
# from selenium.webdriver.common.by import By
from page.page_login import LoginProxy
from page.page_handle_contract01 import ProxyHandleContract
from page.page_enterprise_console2_company_mes import ProxyCompanyMes
from page.page_com_seal import ProxyComSeal
from utils import UtilsDriver


class TestHandleContract:
  #setup_class方法：类执行前都会执行的方法  
    def setup_class(self):  # 实例化page中的业务对象
        self.driver = UtilsDriver.get_driver()
        self.driver.implicitly_wait(6)
        self.login_proxy = LoginProxy()
        self.proxy_company_mes = ProxyCompanyMes()
        self.proxy_company_seal=ProxyComSeal()
        self.proxy_handle_contract=ProxyHandleContract()
        self.absolute_xpath = os.path.abspath(os.path.dirname(os.getcwd()))
        print("当前路径：" + self.absolute_xpath)

        self.now_time = datetime.datetime.now()
        self.now_time_str = self.now_time.strftime('%Y-%m-%d')
        self.yesterday_time = self.now_time + datetime.timedelta(days=-1)
        self.yesterday_time_str = self.yesterday_time.strftime('%Y-%m-%d')
        self.tomorrow_time = self.now_time + datetime.timedelta(days=1)
        self.tomorrow_time_str = self.tomorrow_time.strftime('%Y-%m-%d')
        print("yesterday_time_str:" + self.yesterday_time_str)
        print("tomorrow_time_str:" + self.tomorrow_time_str)
	#调用正向登录的方法，放在 setup_class中，则该类执行之前都会执行登录的方法
        self.login_proxy.login("13800138000", "****密码")
        print("每个类前，登录成功")
        time.sleep(1)

    #setup方法：每个方法执行前都会执行的方法  
    def setup(self):
        UtilsDriver.get_element_utils_wait("//div[@class='nav-logo-link flex-y-center']").click()
        print("每个方法前，点击系统首页")
        time.sleep(1)
        
 #teardown_class方法：类执行前都会执行的方法         
    def teardown_class(self):
        time.sleep(3)
        UtilsDriver.get_driver().quit()

 
#parametrize装饰器，实现参数化（则以下用例会执行三遍，每遍的task_xpath都取不一样的值）
    @pytest.mark.parametrize("task_xpath",
                                 [(f"{os.path.abspath(os.path.dirname(os.getcwd()))}/test_file/PDF.pdf")
                                       ,
                                    (f"{os.path.abspath(os.path.dirname(os.getcwd()))}/test_file/doc.doc"),
                                   (f"{os.path.abspath(os.path.dirname(os.getcwd()))}/test_file/docx.docx")])
    def test_001_initiate_contract_with_one_verify_one_company_one_person_by_order(self,task_xpath):#page_handle_contract，经办合同-点第一个企业-发起合同签署-直接发起，签署方式1，参与者一企业，二个人，含有合同审批方式（审批一人），审批通过，意愿签署方式默认

        """
        企业参与方发起，一个个人参与方，有企业审批流【在审批管理-待我审批】顺序签署，
        :param task_xpath:
        :return:
        """
        n = randint(1, 9999999)#取随机数字
        task_name = "任务名称" + str(n)#校验唯一性的任务名称
        self.proxy_handle_contract.CONTRACT_INITIATED_DIRECTLY_1(task_name,
                            task_xpath,
                             "**公司",
                             "周**",
                             "13800138000",
                             "周*2",
                             "13800138001")
        time.sleep(3)
        mes=UtilsDriver.get_attribute("//div[@class='bg-color box margin-t11']/div[2]", "class")
        print("生成截图")
        allure.attach(UtilsDriver.get_driver().get_screenshot_as_png(), "截图", allure.attachment_type.PNG)

        assert "success-text" in mes
        time.sleep(2)

        print("---在本机号审批同意")
        self.proxy_handle_contract.VERIFY_ON_THE_LOGIN_PHONE1(task_name)

        print("---甲方在本机签署")
        self.proxy_handle_contract.SIGN_CONTRACT_ON_COMPANY_HANDLE_BY_ME(task_name)
        time.sleep(5)
        mes=UtilsDriver.get_mes("//div[@class='success-text']")
        print("生成截图")
        allure.attach(UtilsDriver.get_driver().get_screenshot_as_png(), "截图", allure.attachment_type.PNG)

        assert "当前签署已完成" in mes
        time.sleep(2)

        print("---退出当前帐号，重新登录138001380001")
        self.proxy_company_mes.LOGIN_OUT_LOGIN_AGAIN(phone="13800138001")
        time.sleep(2)

        print("---乙方在登录好的号上签署")
        self.proxy_handle_contract.SIGN_CONTRACT_ON_PERSONAL_HANDLE_BY_ME(task_name)
        time.sleep(5)
        mes = UtilsDriver.get_mes("//div[@class='success-text']")
        print("生成截图")
        allure.attach(UtilsDriver.get_driver().get_screenshot_as_png(), "截图", allure.attachment_type.PNG)
        assert "当前签署已完成" in mes