Base文件下basecase内selenium的二次封装

直接看代码吧

from selenium import webdriver
from selenium.webdriver import ActionChains
import time
import os
from utils.logger import Logger
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common import TimeoutException
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By

logger = Logger(logger='BasePage').getlog()
url = "www.baidu.com"

class BasePage(object):

    def __init__(self, driver, path=None):
        # self.driver = webdriver.Chrome()
        self.driver = driver
        self.timeout = 10
        self.t = 0.4
        self.url = url
        self.open(path)
        self.driver.maximize_window()
        self.wait(30)

    # 打开链接
    def open(self, path=None):
        """如果不传入path，则不打开页面"""
        if path == None:
            url = None
            logger.info("没有带钥匙，检查一下")
        else:
            url = self.url + path
            logger.info(" 测试地址是:{}".format(url))

        if path != None:
            self.driver.get(url)
            logger.info("已经打开:{}".format(url))

    # 寻找元素
    def find_ele(self, selector):
        # return self.driver.find_element(*selector)
        # try:
        #     ele = self.driver.find_element(*selector)
        # except NameError as e:
        #     logger.error("找 %s 失败" % e)
        # except:
        #     logger.info("怎么找不到{}".format(selector))
        #     self.save_screenshot()
        #     return False
        #
        # else:
        #     logger.info("{}哪里跑".format(selector))
        #     return ele

        try:
            ele = WebDriverWait(self.driver, self.timeout, self.t).until(EC.visibility_of_element_located(selector))
            if ele.is_displayed():
                logger.info("定位{}成功".format(selector))
                return ele
        except:
            logger.info('%s页面中未能找到元素%s' % (self, selector))
            return ""

    # 点击元素
    def click(self, selector):
        ele = self.find_ele(selector)

        try:
            ele.click()
            logger.info("点击{}成功".format(selector))
            # logger.info("点击'{}'成功".format(ele.text))
            # 注释掉原因是，点击成功后页面发生跳转后，因为需要打印log，
            # 所以需要再去查询元素的文本值，但是页面已经切换，之前页面的元素已经定位不到，会报StaleElementReferenceException异常
        except NameError as e:
            ele.click()
            logger.info("点击失败 %s" % e)
            self.save_screenshot()

    # 输入文本
    def input_text(self, selector, text):

        ele = self.find_ele(selector)
        """先清空内容，再输入"""
        ele.clear()
        try:
            ele.send_keys(text)
            logger.info("写入 %s" % text)
        except NameError as e:
            logger.error("写入失败 %s " % e)
            self.save_screenshot()

    # 关闭浏览器
    def quit(self):
        self.driver.quit()

    # 获取单个元素文本值
    def get_text(self, selector):
        ele = self.find_ele(selector)
        try:
            logger.info("获取的文本值是:{}".format(ele.text))
            return ele.text

        except NameError as e:
            logger.error("获取失败 %s" % e)
            """截图"""
            self.save_screenshot()

    # 隐式等待
    def wait(self, seconds):
        self.driver.implicitly_wait(seconds)
        logger.info("隐式等待 %d 秒." % seconds)

    # 截图
    def save_screenshot(self):
        """项目路径"""
        Root_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        """文件路径"""
        file_path = (os.path.join(Root_directory), 'Screenshots\\')
        """时间设置"""
        rq = time.strftime("%Y-%m-%d %H%M%S", time.localtime(time.time()))
        """图片名称"""
        screen_name = file_path + rq + '.png'
        try:
            self.driver.get_screenshot_as_file(screen_name)
            logger.info("抓拍成功")
        except NameError as e:
            logger.error("抓拍失败 %s" % e)
            self.save_screenshot()

    # 鼠标悬停
    def mouse_hover(self, selector):
        ActionChains(self.driver).move_to_element(self.find_ele(selector)).perform()

    def back(self):
        self.driver.back()

    def refresh(self):
        self.driver.refresh()

    # 聚焦到某个元素位置
    def target(self, selector):
        target = self.find_ele(selector)
        self.driver.execute_script('arguments[0].scrollIntoView();', target)

    def intelligent_wait(self, selector,timeout=20,  judgment_type=0, message="元素未找到", y_or_n=True, is_click=False):
        # """显示等待
        #             y_or_n:boolen值，True直到满足条件时退出等待。Flase直到不满足条件时退出等待
        #             judgment_type:0为判断元素是否可见，1为判断元素是否加到dom树里
        #         """
        # if y_or_n:
        #     if judgment_type == 0:
        #         WebDriverWait(self.driver, 30, 0.5).until(EC.visibility_of_element_located(selector), message)
        #     elif judgment_type == 1:
        #         WebDriverWait(self.driver, 30, 0.5).until(EC.presence_of_element_located(selector), message)
        # else:
        #     if judgment_type == 0:
        #         WebDriverWait(self.driver, 30, 0.5).until_not(EC.visibility_of_element_located(selector), message)
        #     elif judgment_type == 1:
        #         WebDriverWait(self.driver, 30, 0.5).until_not(EC.presence_of_element_located(selector), message)
        # if is_click:
        #     self.find_element(selector).click()

        try:
            return WebDriverWait(self.driver, timeout, 0.7).until(EC.visibility_of_element_located(selector))
        except TimeoutException:
            print('未获取到元素')
            return False
        except Exception as e:
            return False

    def is_visibility(self, selector):
        """元素可见返回本身，不可见返回False"""
        result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.visibility_of_element_located(selector))
        return result

    def is_invisibility(self, selector):
        """元素可见返回本身，不可见返回True，没有找到元素也返回True"""
        result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.invisibility_of_element_located(selector))
        return result

    def is_clickAble(self, selector):
        """元素可以点击返回本身，不可点击返回False"""
        result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.element_to_be_clickable(selector))
        return result

    def is_locator(self, selector):
        """判断元素有没有被定位到（并不意味着可见），定位到返回element，没有定位到返回False"""
        result = WebDriverWait(self.driver, self.timeout, self.t).until(EC.presence_of_element_located(selector))
        return result