UI python 中的basePage 类元素的最全的相关公共方法

basePages 类封装

类相关功能说明

1、获取元素功能
2、点击元素
3、输入内容
4、打开浏览器…

class BasePage():
    """
    获取元素
    点击元素
    输入内容
    """
    def __init__(self):
        # 初始化操作获取浏览器
        self.driver = Driver().get_driver()
        self.locators = read_yaml(configs_path + 'allelements.yaml')[self.__class__.__name__]
        # print(self.locators.items())
        print("当前子类的类名是——————>", self.__class__.__name__)
        for elementname, locator in self.locators.items():  # 遍历字典kv
            setattr(self, elementname, locator)  # 给self设置一个变量elementname的值是locator
        """删除前data的数据 data为int 类型"""
        self.log = MyLog().delete_log(1)
        log.info("删除超过1天的日志信息")

    def __call__(self, f):
        def inner(*args):
            try:
                return f(*args)
            except:
                curtime = strftime("%Y%m%d%H%M")
                self.driver.get_screenshot_as_file('../%s.jpg' % curtime)
                raise

        return inner

    def open_url(self, url):

        """
        :param url: 打开浏览器的URL
        :return:
        """
        self.driver.get(url)
        log.info("打开至url页面")

    def max_windows(self):
        self.driver.maximize_window()
        log.info("页面最大化")

    def take_screenshot(self):  # 保存截图
        """
        :param img_description:   图片描述 格式为 页面名称——功能名
        :return:截图并保存在根目录下的Screenshots文件夹下
        """
        curtime = strftime("%Y-%m-%d-%H-%M-%S")
        screenshots_name = screenshots_path + f'/{curtime}.png'
        try:
            self.driver.save_screenshot(screenshots_name)
        except Exception as e:
            log.exception("网页截图失败")
            log.error("错误类型:", e.__class__.__name__)
            log.error("错误类型:", e)
        else:
            log.info("截图成功，{}截图存放在：{}".format(screenshots_name, screenshots_path))

    def get_element(self, locator):
        """
        元素定位方法
        :param locator: 元素定位器
        :return:
        """
        try:
            ele = WebDriverWait(self.driver, Env.OUTTIME, Env.POLL_FREQUENCY).until(
                EC.visibility_of_element_located(locator))

        except Exception as e:
            log.info('元素定位不到')
            log.error("错误类型:", e.__class__.__name__)
            log.error("错误类型:",traceback.format_exc())
            self.take_screenshot()
            raise
        else:
            log.info("查找可见 {} 成功！".format(locator))
        return ele

    def get_elements(self, locators):
        """
       一组元素定位方法
       :param locator: 元素定位器
       :return:
        """
        try:
            return WebDriverWait(self.driver, Env.OUTTIME, Env.POLL_FREQUENCY).until(
                EC.visibility_of_all_elements_located(locators))
        except Exception as e:
            # 定位不到时，截图，打印日志
            log.info(f'{locators}元素定位不到')
            log.error("错误类型:", e.__class__.__name__)
            log.error("错误类型:",traceback.format_exc())
            log.error(traceback.format_exc())
            self.take_screenshot()

    def element_click(self, locator):
        """
        :param locator: 元素定位
        :return: 返回元素的点击操作
        """
        self.get_element(locator).click()

        log.info(f"该元素{locator}点击成功")

    def input_text(self, locator, text, clear=False):
        """
        1、进行输入内容
        2、先进行清空后输入内容
        :param locator: 要输入内容的元素
        :param text: 输入的内容
        :param clear:默认不需要进行清空，直接输入内容
        :return:
        """
        if clear == True:
            self.get_element(locator).clear()
            self.get_element(locator).send_keys(text)
        else:
            self.get_element(locator).send_keys(text)
            log.info(f"该元素{locator}输入成功")

    def get_element_text(self, locator):
        """
        获取元素的文本
        :param locator: 元素的定位器
        :return:
        """
        return self.get_element(locator).text

    def get_elements_text(self, locators):
        """
        获取元素的文本
        :param locator: 元素的定位器
        :return:
        """
        return [ele.text for ele in self.get_elements(locators)]

    def js_do(self, js):
        return self.driver.execute_script(js)

    def open(self, url, title='', timeout=10):
        u"""打开浏览器，并最大化，判断title是否为预期"""
        self.driver.get(url)
        self.driver.maximize_window()
        try:
            WebDriverWait(self.driver, timeout, 1).until(EC.title_contains(title))
        except TimeoutException:
            print("open %s title error" % url)
        except Exception as msg:
            print("Error:%s" % msg)

    def find_element(self, locator, timeout=10):
        u"""定位元素，参数locator为原则"""
        try:
            element = WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_element_located(locator))
            return element
        except:
            print("%s 页面未找到元素 %s" % (self, locator))

    def find_elements(self, locator, timeout=10):
        u"""定位一组元素"""
        elements = WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_all_elements_located(locator))
        return elements

    def is_text_in_element(self, text, locator, timeout=10):
        u"""判断是否定位到元素"""
        try:
            result = WebDriverWait(self.driver, timeout, 1).until(EC.text_to_be_present_in_element(locator, text))
        except TimeoutException:
            print("元素未定位到:" + str(locator))
            return False
        else:
            return result

    def is_title(self, title, timeout=10):
        u"""判断title完全相等"""
        result = WebDriverWait(self.driver, timeout, 1).until(EC.title_is(title))
        return result

    def is_title_contains(self, title, timeout=10):
        u"""判断是否包含title"""
        result = WebDriverWait(self.driver, timeout, 1).until(EC.title_contains(title))
        return result

    def is_select(self, locator, timeout=10):
        u"""判断元素是否被选中"""
        result = WebDriverWait(self.driver, timeout, 1).until(EC.element_located_to_be_selected(locator))
        return result

    def is_select_be(self, locator, timeout=10, selected=True):
        u"""判断元素的状态"""
        return WebDriverWait(self.driver, timeout, 1).until(EC.element_located_selection_state_to_be(locator, selected))

    def is_alert_present(self, timeout=10):
        u"""判断页面有无alert弹出框，有alert返回alert，无alert返回FALSE"""
        try:
            return WebDriverWait(self.driver, timeout, 1).until(EC.alert_is_present())
        except:
            print("No Alert Present")

    def is_visibility(self, locator, timeout=10):
        u"""判断元素是否可见，可见返回本身，不可见返回FALSE"""
        return WebDriverWait(self.driver, timeout, 1).until(EC.visibility_of_element_located(locator))

    def is_invisibility(self, locator, timeout=10):
        u"""判断元素是否可见，不可见，未找到元素返回True"""
        return WebDriverWait(self.driver, timeout, 1).until(EC.invisibility_of_element_located(locator))

    def is_clickable(self, locator, timeout=10):
        u"""判断元素是否可以点击，可以点击返回本身，不可点击返回FALSE"""
        return WebDriverWait(self.driver, timeout, 1).until(EC.element_to_be_clickable(locator))

    def is_located(self, locator, timeout=10):
        u"""判断元素是否定位到（元素不一定是可见），如果定位到返回Element，未定位到返回FALSE"""
        return WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_element_located(locator))

    def move_is_element(self, locator):
        u"""鼠标悬停操作"""
        element = self.find_element(locator)
        ActionChains(self.driver).move_to_element(element).perform()

    def back(self):
        u"""返回到旧的窗口"""
        self.driver.back()

    def forward(self):
        u"""前进到新窗口"""
        self.driver.forward()

    def close(self):
        u"""关闭窗口"""
        self.driver.close()

    def quit(self):
        u"""关闭driver和所有窗口"""
        self.driver.quit()

    def get_title(self):
        u"""获取当前窗口的title"""
        return self.driver.title

    def get_current_url(self):
        u"""获取当前页面url"""
        return self.driver.current_url

    def get_text(self, locator):
        u"""获取文本内容"""
        return self.find_element(locator).text

    def get_browser_log_level(self):
        u"""获取浏览器错误日志级别"""
        lists = self.driver.get_log('browser')
        list_value = []
        if lists.__len__() != 0:
            for dicts in lists:
                for key, value in dicts.items():
                    list_value.append(value)
        if 'SEVERE' in list_value:
            return "SEVERE"
        elif 'WARNING' in list_value:
            return "WARNING"
        return "SUCCESS"

    def get_attribute(self, locator, name):
        u"""获取属性"""
        return self.find_element(locator).get_attribute(name)

    def get_screen_as_file(self, func):
        """异常自动截图"""

        def inner(*args, **kwargs):
            try:
                func(*args, **kwargs)
            except:
                self.screen()
                raise

        return inner

    def screen(self):
        u"""浏览器页面截图"""
        nowtime = time.strftime("%Y_%m_%d_%H_%M_%S")
        self.driver.get_screenshot_as_file("%s.png" % nowtime)

    def js_input_text(self, locator, value):
        """
        :param js:
        :param locator:元素定位方法
        :param value:输入的值
        :return:
        """
        js = 'arguements[0].value=arguements[1]'
        return self.driver.execute_script(js, locator, value)

    def js_fours_element(self, locator):
        u"""聚焦元素"""
        element = self.find_element(locator)
        self.driver.execute_script("arguments[0].scrollIntoView();", element)

    def js_scroll_top(self):
        u"""滑动到页面顶部"""
        js = "window.scrollTo(0,0)"
        self.driver.execute_script(js)

    def js_scroll_end(self):
        u"""滑动到页面底部"""
        js = "window.scrollTo(0, document.body.scrollHeight)"
        self.driver.execute_script(js)

    def select_by_index(self, locator, index):
        u"""通过所有index，0开始,定位元素"""
        element = self.find_element(locator)
        Select(element).select_by_index(index)

    def select_by_value(self, locator, value):
        u"""通过value定位元素"""
        element = self.find_element(locator)
        Select(element).select_by_value(value)

    def select_by_text(self, locator, text):
        u"""通过text定位元素"""
        element = self.find_element(locator)
        Select(element).select_by_visible_text(text)