一: 打开win10中安装的浏览器

1. 打开的浏览器有：谷歌/火狐/ie/edge

2. 当浏览器的driver没有配置在path环境下时，在启动浏览器时需要传入driver的所在位置

3. 其中火狐浏览器安装不为默认路径时也需要配置说明

4. 具体代码如下：

  1. import os
  2.  
  3. from selenium import webdriver
  4.  
  5. from util_tools.storage.read_model_file import ReadModelIni
  6.  
  7. argument = ReadModelIni("system_settings.ini")
  8. driver_path = argument.get_value("driver_browser", "driver_path")
  9. chrome_driver = argument.get_value("driver_browser", "chrome_driver")
  10. ie_driver = argument.get_value("driver_browser", "ie_driver")
  11. firefox_driver = argument.get_value("driver_browser", "firefox_driver")
  12. microsoft_driver = argument.get_value("driver_browser", "microsoft_driver")
  13. del argument
  14.  
  15. # https://www.cnblogs.com/ppppying/p/6143658.html IE浏览器配置方法文章说明
  16.  
  17. class BrowserPrepare(object):
  18.     """
  19.     工作内容:
  20.     1. 打开浏览器
  21.     """
  22.  
  23.     def run_web_browser(self, url: str, driver_browser: str = 'chrome', wait_time: int = 5):
  24.         """
  25.         打开浏览器并进入相应的网址
  26.         :param wait_time:
  27.         :param url:
  28.         :param driver_browser:
  29.         :return:
  30.         """
  31.         self.open_driver_browser(driver_browser, wait_time)
  32.         self.input_browser_url(url)
  33.  
  34.     def open_driver_browser(self, driver_browser: str = 'chrome', wait_time: int = 5):
  35.  
  36.         # 创建浏览器对象
  37.         if driver_browser.capitalize() in 'Chrome':
  38.             self.chrome_browser()
  39.         elif driver_browser.capitalize() in 'Firefox':
  40.             self.firefox_browser()
  41.         elif driver_browser.capitalize() in 'Edge':
  42.             self.edge_browser()
  43.         else:
  44.             self.ie_browser()
  45.         # 浏览器窗口最大化,程序运行过程中有些问题就是因为窗口没有最大化导致的.
  46.         self.driver.maximize_window()
  47.         # 等待网页加载，加载时间为10s，加载完就跳过
  48.         # 隐形等待时间和显性等待时间不同时，默认使用两者之间最大的那个
  49.         self.driver.implicitly_wait(wait_time)
  50.         pass
  51.  
  52.     def input_browser_url(self, url: str):
  53.         # 输入网址
  54.         self.driver.get(url)
  55.         pass
  56.  
  57.     def close_driver_browser(self, _quit=None):
  58.         # 关闭并退出浏览器
  59.         self.driver.quit()
  60.         pass
  61.  
  62.     def chrome_browser(self):
  63.         """
  64.         调用函数，实现打开谷歌浏览器的步骤
  65.         :return:
  66.         """
  67.         self.driver = webdriver.Chrome(executable_path=os.path.join(driver_path, chrome_driver))
  68.  
  69.     def ie_browser(self):
  70.         """
  71.         调用函数，实现打开ie浏览器的步骤
  72.         :return:
  73.         """
  74.         # 实现全局变量的引用
  75.         self.driver = webdriver.Ie(executable_path=os.path.join(driver_path, ie_driver))
  76.  
  77.     def edge_browser(self):
  78.         """
  79.         调用函数，实现打开edge浏览器的步骤
  80.         :return:
  81.         """
  82.         # 实现全局变量的引用
  83.         self.driver = webdriver.Edge(executable_path=os.path.join(driver_path, microsoft_driver))
  84.  
  85.     def firefox_browser(self, options=None):
  86.         """
  87.         调用函数，实现打开火狐浏览器的步骤
  88.         :return:
  89.         """
  90.  
  91.         # 实现全局变量的引用,当火狐安装路径不为默认路径时（即C盘）才需要填写firefox_bin
  92.         firefox_bin = os.path.abspath(r"E:\Program Files\Mozilla Firefox\firefox.exe")
  93.         os.environ["webdriver.firefox.bin"] = firefox_bin
  94.  
  95.         # 代码加载火狐驱动
  96.         firefox_driver_path = os.path.abspath(os.path.join(driver_path, firefox_driver))
  97.         self.driver = webdriver.Firefox(options, executable_path=firefox_driver_path)
  98.  
  99.     def mobile_phone_mode(self):
  100.         '''
  101.         将谷歌浏览器设置为手机模式
  102.         :return:
  103.         '''
  104.         from selenium.webdriver.chrome.options import Options
  105.         # 有效的移动设备Galaxy S5.Nexus 5X.Nexus 6P
  106.         # mobile_emulation = {"deviceName": "iPhone 7"}
  107.  
  108.         mobile_emulation = {
  109.             "deviceMetrics": {"width": 360, "height": 640, "pixelRatio": 3.0},
  110.             "userAgent": "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) CriOS/56.0.2924.75 Mobile/14E5239e Safari/602.1"}
  111.  
  112.         # mobile_emulation = {"browserName": "IE"}
  113.         options = Options()
  114.         options.add_experimental_option("mobileEmulation", mobile_emulation)
  115.         return options
  116.  
  117.     def chrome_prefs_flash(self):
  118.         '''
  119.         当谷歌浏览器运行时，不会加载flash
  120.         :return:
  121.         '''
  122.         from selenium.webdriver.chrome.options import Options
  123.  
  124.         prefs = {
  125.             "profile.managed_default_content_settings.images": 1,
  126.             "profile.content_settings.plugin_whitelist.adobe-flash-player": 1,
  127.             "profile.content_settings.exceptions.plugins.*,*.per_resource.adobe-flash-player": 1
  128.         }
  129.  
  130.         options = Options()
  131.         options.add_experimental_option("prefs", prefs)
  132.         return options
  133.  
  134.     def firefox_prefs_flash(self):
  135.         '''
  136.         当firefox运行时，flash不会加载
  137.         :return:
  138.         '''
  139.         options = webdriver.FirefoxProfile()
  140.         # 其中plugin.state.flash后的数值可以为0,1,2； 0：禁止，1：询问，2：允许。
  141.         options.set_preference("plugin.state.flash", 2)
  142.         return options

5. 思路为:

当需要打开浏览器时，需要传入url，浏览器对象默认为谷歌浏览器，浏览器元素默认加载时间为5s。

而浏览器驱动的所在位置存储在ini文件中，文件运行时去读取指定的驱动位置。

二: 创建元素识别类

1. 该类主要识别元素是否存在或者元素是否消失，并且继承浏览器操作类

2. 对传入的元素类型及路径组合体进行切割，并识别出相应的by对象。由隐形等待对象WebDriverWait来判断元素存在性

切割元素路径

  1. way, locator = ele_para.split(">>")
  2. ele_by = self.is_visible_driver(locator, way)

by对象判断

  1.         by_ele = {"Css": 'CSS_SELECTOR', "Id": 'ID', "Xpath": 'XPATH', "Name": 'NAME'}
  2.         # capitalize不区分大小写
  3.         if way.capitalize() in by_ele.keys():
  4.             ele_by = by_ele.get(way.capitalize())
  5.             ele_by = getattr(By, ele_by)
  6.             ele_by = (ele_by, locator)
  7.         else:
  8.             ele_by = None
  9.         del by_ele
  10.         return ele_by

3. 具体代码：

  1. class ActionVisible(BrowserPrepare):
  2.     """
  3.     工作内容:
  4.     1.执行元素校验动作 = [click,input,visible]
  5.     """
  6.  
  7.     def __init__(self):
  8.         self.log = Logger('ActionVisible')
  9.         pass
  10.  
  11.     def is_visible_driver(self, locator: str, way: str) -> ():
  12.         """
  13.         根据类型定义相应的by元素对象
  14.         :param locator:     元素路径
  15.         :param way:     元素类路径类型
  16.         :return:
  17.         """
  18.         by_ele = {"Css": 'CSS_SELECTOR', "Id": 'ID', "Xpath": 'XPATH', "Name": 'NAME'}
  19.         # capitalize不区分大小写
  20.         if way.capitalize() in by_ele.keys():
  21.             ele_by = by_ele.get(way.capitalize())
  22.             ele_by = getattr(By, ele_by)
  23.             ele_by = (ele_by, locator)
  24.         else:
  25.             ele_by = None
  26.         del by_ele
  27.         return ele_by
  28.  
  29.     def differentiate_all_exist(self, ele_by, timeout=10):
  30.         """
  31.         根据某个元素路径,返回符合该路径的全部元素
  32.         :param ele_by: 在is_visible_driver中返回的元素by属性
  33.         :param timeout: 元素查找时间,默认为5s
  34.         :return:
  35.         """
  36.         try:
  37.             ele = ui.WebDriverWait(self.driver, timeout).until(
  38.                 EC.visibility_of_all_elements_located(ele_by))
  39.             return ele
  40.         except Exception as e:
  41.             fun_name = inspect.stack()[0][3]
  42.             print("%s发生错误%s,元素对象为%s" % (fun_name, e, ele_by))
  43.             return False
  44.  
  45.     def prompt_all_exist(self, prompt, ele_by, timeout=5):
  46.         try:
  47.             ele = ui.WebDriverWait(prompt, timeout).until(
  48.                 EC.visibility_of_all_elements_located(ele_by))
  49.             return ele
  50.         except Exception as e:
  51.             fun_name = inspect.stack()[0][3]
  52.             print("%s发生错误%s,元素对象为%s" % (fun_name, e, ele_by))
  53.             return False
  54.  
  55.     def differentiate_single_exist(self, ele_by, timeout=5):
  56.         """
  57.         根据某个元素路径,第一个符合该路径的元素
  58.         :param ele_by: 在is_visible_driver中返回的元素by属性
  59.         :param timeout: 元素查找时间,默认为5s
  60.         :return:
  61.         """
  62.         try:
  63.             ele = ui.WebDriverWait(self.driver, timeout).until(
  64.                 EC.visibility_of_element_located(ele_by))
  65.             return ele
  66.         except Exception as e:
  67.             fun_name = inspect.stack()[0][3]
  68.             print("%s发生错误%s,元素对象为%s" % (fun_name, e, ele_by))
  69.             return False
  70.  
  71.     def differentiate_not_exist(self, ele_by, timeout=5):
  72.         """
  73.         识别某个元素是否从界面上消失
  74.         :param ele_by:在is_visible_driver中返回的元素by属性
  75.         :param timeout:
  76.         :return:
  77.         """
  78.         try:
  79.             ui.WebDriverWait(self.driver, timeout).until_not(EC.element_to_be_clickable(ele_by))
  80.             return True
  81.         except Exception as e:
  82.             fun_name = inspect.stack()[0][3]
  83.             print("%s发生错误%s,元素对象为%s" % (fun_name, e, ele_by))
  84.             return False
  85.  
  86.     def is_visible_single_driver(self, ele_para, timeout=5):
  87.         """
  88.         识别某个元素是否加载完毕
  89.         :param ele_para: 元素路径 和 元素类型 的组合
  90.         :param timeout: 查找元素的超时时间
  91.         :return:
  92.         """
  93.         way, locator = ele_para.split(">>")
  94.         ele_by = self.is_visible_driver(locator, way)
  95.         return self.differentiate_single_exist(ele_by, timeout)
  96.  
  97.     def is_visible_all_driver(self, ele_para, timeout=5):
  98.         """
  99.         识别元素路径相同的全部元素
  100.         :param ele_para:
  101.         :param timeout:
  102.         :return:
  103.         """
  104.         way, locator = ele_para.split(">>")
  105.         ele_by = self.is_visible_driver(locator, way)
  106.         return self.differentiate_all_exist(ele_by, timeout)
  107.  
  108.     def is_visible_all_prompt(self, prompt, locator, way, timeout=5):
  109.         """
  110.         识别元素路径相同的全部元素
  111.         :param prompt:
  112.         :param locator:
  113.         :param way:
  114.         :param timeout:
  115.         :return:
  116.         """
  117.         ele_by = self.is_visible_driver(locator, way)
  118.         return self.prompt_all_exist(prompt, ele_by, timeout)
  119.  
  120.     def is_visible_not_driver(self, locator, way, timeout=5):
  121.         """
  122.         判断某个元素是否消失
  123.         :param locator:
  124.         :param way:
  125.         :param timeout:
  126.         :return:
  127.         """
  128.  
  129.         ele_by = self.is_visible_driver(locator, way)
  130.         return self.differentiate_not_exist(ele_by, timeout)
  131.  
  132.     def is_visible_click(self, prompt):
  133.         """
  134.         执行点击操作
  135.         :param prompt:
  136.         :return:
  137.         """
  138.         prompt.click()
  139.         sleep(1)
  140.  
  141.     def is_visible_input(self, attribute, parameter):
  142.         """
  143.         统一封装元素输入操作
  144.         :param attribute: 元素对象
  145.         :param parameter: 输入内容
  146.         :return:
  147.         """
  148.         self.set_action_funname(inspect.stack()[0][3])
  149.         attribute.click()
  150.         attribute.clear()
  151.         attribute.send_keys(parameter)
  152.         self.log.info("输入的信息(%s)" % parameter)
  153.         sleep(1)
  154.  
  155.     def set_action_funname(self, fun_name):
  156.         self.log.fun_name = fun_name

三: 元素操作类

1. 该类继承元素识别类

2. 主要用于元素点击、输入、返回元素text或者value

3. 代码如下

  1. class ActionParsing(ActionVisible):
  2.     """
  3.     主要实现selenium一些内置的动作封装
  4.     例如：
  5.         元素输入
  6.         元素点击
  7.         返回元素值
  8.     """
  9.  
  10.     def is_input_execute(self, ele_para, parameter, timeout=5):
  11.         """
  12.         通过元素类型来找到元素,并输入内容
  13.         :param ele_para:  元素路径
  14.         :param parameter:  需要输入的内容
  15.         :param timeout: 元素查找时间
  16.         :return:
  17.         """
  18.         attribute = self.is_visible_single_driver(ele_para, timeout)
  19.         self.is_visible_input(attribute, parameter)
  20.         self.log.info("%s元素输入内容为%s" % (ele_para, parameter))
  21.  
  22.     def is_click_execute(self, ele_para, timeout=5):
  23.         """
  24.         通过元素类型来找到元素并执行点击操作
  25.         :param ele_para:  元素路径
  26.         :param timeout: 元素查找时间
  27.         :return:
  28.         """
  29.         attribute = self.is_visible_single_driver(ele_para, timeout)
  30.         self.is_visible_click(attribute)
  31.         self.log.info("%s元素进行点击操作" % ele_para)
  32.  
  33.     def get_text_value(self, ele_para: str, attr: str = None, timeout: int = 5) -> str:
  34.         """
  35.         获取元素的text或者attribute
  36.         :param ele_para:  元素路径
  37.         :param attr:  为none时获取元素text,不为空时获取元素的attribute属性值
  38.         :param timeout: 元素可见超时时间
  39.         :return:
  40.         """
  41.         attribute = self.is_visible_single_driver(ele_para, timeout)
  42.         if type(attribute) is bool:
  43.             return attribute
  44.         else:
  45.             if attr:
  46.                 attribute = attribute.get_attribute(attr)
  47.             else:
  48.                 attribute = attribute.text
  49.         self.log.info("%s元素获取(%s)属性值为%s" % (ele_para, attr, attribute))
  50.         return attribute

四: js内置操作类

1. 继承元素操作类，该类主要是通过js来对元素进行输入/点击/焦点获取及失去

2. 代码如下：

  1. class ActionBuiltWeb(ActionVisible):
  2.     """
  3.     通过web内置的js来做操作。
  4.     例如：
  5.         元素查找
  6.         元素点击
  7.         元素输入
  8.         聚焦及移除焦点
  9.     """
  10.  
  11.     def cursor_execute_id(self, locator, parameter):
  12.         """
  13.         利用js找到相关id的元素,直接对value进行数据修改
  14.         :param locator: 元素对象
  15.         :param parameter: 输入内容
  16.         :return:
  17.         """
  18.         self.driver.execute_script("document.getElementById(\'" + locator + "\').value=\'" + parameter + "\';")
  19.         sleep(1)
  20.  
  21.     def cursor_execute_ordinal(self, cursor, parameter):
  22.         """
  23.          根据元素对象本身,通过JS对value进行写入
  24.         :param cursor:  元素对象本身
  25.         :param parameter:   需要输入的信息
  26.         :return:
  27.         """
  28.         self.driver.execute_script("\'" + cursor + "\'.value=\'" + parameter + "\';")
  29.         sleep(1)
  30.  
  31.     def cursor_execute_selectop(self, locator, parameter):
  32.         """
  33.         利用js找到相关selctop的元素,直接对value进行数据修改
  34.         :param locator: 元素对象
  35.         :param parameter: 输入内容
  36.         :return:
  37.         """
  38.         self.driver.execute_script("document.querySelector(\'" + locator + "\').value=\'" + parameter + "\';")
  39.         sleep(1)
  40.  
  41.     def id_confirm_execute(self, locator):
  42.         """
  43.         利用js语法通过id执行点击操作
  44.         :param locator:     元素属性中,ID的属性值
  45.         :return:
  46.         """
  47.         self.driver.execute_script("document.getElementById(\'" + locator + "\').click();")
  48.         pass
  49.  
  50.     def css_confirm_execute(self, locator):
  51.         """
  52.         利用js语法通过元素selector执行点击操作
  53.         :param locator: 元素属性中,selector的属性值
  54.         :return:
  55.         """
  56.         self.driver.execute_script("document.querySelector(\'" + locator + "\').click();")
  57.         pass
  58.  
  59.     def attribute_focus_blur(self, ele_attr, cursor_type):
  60.         """
  61.         通过元素id,实现元素获取焦点及失去焦点的操作
  62.         :param ele_attr:    元素的id
  63.         :param cursor_type: 聚焦或失焦
  64.         :return:
  65.         """
  66.         if 'blur' == cursor_type:
  67.             self.driver.execute_script("document.getElementById(\'" + ele_attr + "\').blur();")
  68.             pass
  69.         elif 'focus' == cursor_type:
  70.             self.driver.execute_script("document.getElementById(\'" + ele_attr + "\').focus();")
  71.  
  72.     def cursor_focus_blur(self, ele_attr, cursor_type: str):
  73.         """
  74.         根据元素对象本身来实现元素获取焦点及失去焦点的操作
  75.         :param ele_attr:  元素对象
  76.         :param cursor_type:  focus聚焦或blur失焦
  77.         :return:
  78.         """
  79.         if 'blur' == cursor_type:
  80.             self.driver.execute_script("arguments[0].blur();", ele_attr)
  81.             pass
  82.         elif 'focus' == cursor_type:
  83.             self.driver.execute_script("arguments[0].focus();", ele_attr)

项目所在位置：

https://github.com/namexiaohuihui/demotest

unittest 运行slenium（二）---打开浏览器及元素操作的更多相关文章

  1. vue中npm run dev运行项目自动打开浏览器

    npm run dev运行项目自动打开浏览器设置自动打开浏览器 // 各种设备设置信息      host: 'localhost', //主机名      port: 8080, // 端口号(默认 ...

  2. unittest 运行slenium（三）---通过数据驱动形式运行用例

    一: 获取数据 获取用例所在位置,通过OpenExcelPandas来读取用例里面的全部数据.通过某个列名来创建新的序号. 并将结果转换成list类型,将其作为ddt数据的来源. 1.  在test文 ...

  3. selenium + python自动化测试unittest框架学习（三）webdriver元素操作（二）

    上一篇是元素的定位,那么定位元素的目的就是对元素进行操作,例如写入文本,点击按钮,拖动等等的操作 (1)简单元素操作 简单元素操作 find_element_by_id("kw") ...

  4. unittest 运行slenium（四）---通过指定用例的形式运行用例

    一: 说明 跟数据驱动唯一的区别为用例数据获取时,及运行方式不同. 其它都基本相同,可参考https://www.cnblogs.com/xiaodingdong/p/11753220.html 二: ...

  5. unittest 运行slenium（五）---运行代码并生成HTMLTestRunner报告

    整体代码如下: import os import sys import time import datetime import unittest import HTMLTestRunner # git ...

  6. unittest 运行slenium（一）---创建配置类

    文章主要是创建: log : 日志文件 excel :文档的读写 ini 及 yaml :文件的读取 一:创建log日志文件 主要是对logging框架进行二次封装并输出自己需要的日志格式 1. 首先 ...

  7. MongoDB 系列(二) C# 内嵌元素操作 聚合使用

    "_id" : "639d8a50-7864-458f-9a7d-b72647a3d226","ParentGuid" : "00 ...

  8. selenium--控制浏览器和简单元素操作

    控制浏览器1.driver.maximize_window() #浏览器最大化2.driver.set_windows_size(480*800) #浏览器设置成移动端大小(480*800),参数数字 ...

  9. UI自动化测试（二）浏览器操作及对元素的定位方法（xpath定位和css定位详解）

    Selenium下的Webdriver工具支持FireFox(geckodriver). IE(InternetExplorerDriver).Chrome(ChromeDriver). Opera( ...

随机推荐

  1. 【ROC+AUC】

    http://m.elecfans.com/article/736801.html https://blog.csdn.net/xyz1584172808/article/details/818392 ...

  2. CF1227D Optimal Subsequences

    思路: 首先对于单个查询(k, p)来说,答案一定是a数组中的前k大数.如果第k大的数字有多个怎么办?取索引最小的若干个.所以我们只需对a数组按照值降序,索引升序排序即可. 多个查询怎么办?离线处理. ...

  3. Python机器学习基础教程-第2章-监督学习之线性模型

    前言 本系列教程基本就是摘抄<Python机器学习基础教程>中的例子内容. 为了便于跟踪和学习,本系列教程在Github上提供了jupyter notebook 版本: Github仓库: ...

  4. 按键板的原理与实现----ADC

    在嵌入式系统产品开发中,按键板的设计是最基本的,也是项目评估阶段必须要考虑的问题.其实现方式又很多种,具体使用那一种就需要结合特定IC的可用IO数量,并综合考虑成本,做出最终选择.本系列文章将介绍多种 ...

  5. 洛谷 题解 P2540 【斗地主增强版】

    [分析] 暴力搜顺子,贪心出散牌 为什么顺子要暴力? 玩过斗地主的都知道,并不是出越长的顺子越好,如果你有一组手牌,3,4,5,6,7,6,7,8,9,10,你一下把最长的出了去,你会单两张牌,不如出 ...

  6. Select 查询语句

    1.1  查询语句 1.1.1     select select 用于从数据看查询数据.语法 select field1,filed2,.. . from tablename [where cond ...

  7. Ubuntu 12.04下Matlab2009a启动后出现某些问题的解决方法

    本文来自linux公社:http://www.linuxidc.com/Linux/2012-08/68346.htm 在Ubuntu 12.04 LTS下正确安装matlab r2009a后,启动起 ...

  8. Quartz.Net—DateBuilder

    定时框架中最重要的就是时间,我们也可以直接使用Cron这种事件格式.  使用其他的时间格式,就可以用DateBuilder快速的创建出需要的时间. 因为quartz是一个定时框架,所以对于操控时间  ...

  9. Linux基础-06-vi编辑器

    1. vi编辑器简介 1) vi的定义:vi是一个UNIX和Linux系统内嵌的标准正文(文字)编辑器,它是一种交互类型的正文编辑器,它可以用来创建和修改正文文件. 2. vi编辑器的操作模式 vi编 ...

  10. Redis string操作命令

    字符串类型  string set 从v2.6.12版本开始,Redis增强了set功能, 语法如下: SET key value [EX seconds] [PX milliseconds] [NX ...