selenium5

0.EC模块presence_of_element_located(locator)

  • locator: 定位器

    • 数据类型,元组

    • ("元素定位方式","对应的定位方式值")

      • 元素的定位方式: 8种

        • "id","class name","partial link text"

      • 对应的定位方式值:

        • id属性值

        • xpath/css表达式

      • 示例:("id","userA") ("class name","telA") ("link text","访问 新浪 网站") ("partial link text","访问") ("css selector","css表达式")

    • WebDriverWait(driver, 10).until(EC.presence_of_element_located(locator)) # 元素定位--单个元素

    • WebDriverWait(driver, 10).until(EC.presence_of_all_elements_located(locator)) # 元素定位--单个元素

1.自动化测试用例编写原则

  • 一个脚本就是一个完整的场景

  • 一个脚本只验证一个功能点

  • 脚本尽量只做正向逻辑验证

    • 正向逻辑≠正确数据

  • 脚本之间不要产生关联,每个脚本都可以独立运行

  • 脚本只对验证点进行验证,不对脚本中每一步骤做验证

2.POM模式

2.1什么是POM模式

pom模式是页面自动化的一个常用的模式;Page Object Module页面 对象 模型

2.2 POM总体思路

一切皆对象

  • 把项目中的每一个页面当做一个对象

  • 把每个页面分为三层

    • 表现层

      • 页面上可见的所有元素

    • 操作层

      • 对页面上所有可见元素的操作(点击,清空,输入)

    • 业务层

      • 对元素操作后所实现的功能

2.3 POM框架文件结构

  • 项目名称

    • common文件夹 --存放公共方法

      • base.py --对selenium做二次封装(基础类)

        • 方法名称一定--见名知意,注释不能缺失

        • 打开浏览器

        • 打开网址

        • 元素定位(单个/一组)

        • 元素操作(点击/输入)

        • 关闭浏览器

        • 下拉菜单

        • alert弹窗

        • iframe

          """
          base.py  对selenium做二次封装
          1.打开浏览器
          2.输入网址
          3.元素定位
          4.元素操作
          """
          from selenium import webdriver
          from selenium.webdriver.support.wait import WebDriverWait
          from selenium.webdriver.support import expected_conditions as EC
          
          
          def open_browser(browser="chrome"):
              """
              打开浏览器
              :param browser: 浏览器名称
              :return:
              """
              if browser == "chrome":
                  driver = webdriver.Chrome()
              elif browser == "firefox":
                  driver = webdriver.Firefox()
              elif browser == "ie":
                  driver = webdriver.Ie()
              else:
                  print("请输入正确的浏览器名称,例如'Chrome','Firefox','ie'")
                  driver = None
              return driver
          
          
          class Base:
              def __init__(self, driver):
                  """
                  初始化浏览器
                  :param driver:
                  """
                  self.driver = driver
          
              def open_url(self,url):
                  """
                  打开网址
                  :param url: 网址
                  :return:
                  """
                  self.driver.get(url)
                  # 浏览器最大化
                  self.driver.maximize_window()
          
              def close(self):
                  """
                  关闭浏览器
                  :return:
                  """
                  self.driver.quit()
          
              def find_element(self, locator: tuple, timeout=10):
                  """
                  定位单个元素
                  :param:locator:定位器,元组格式 例如("id","id属性值")
                  :return:
                  """
                  try:
                      element = WebDriverWait(self.driver,timeout).until(EC.presence_of_element_located(locator))
                      return element
                  except:
                      print(f"元素{locator}没找到")
                      return False
          
              def find_elements(self, locator, timeout=10):
                  """
                  定位一组元素
                  :param locator: 定位器
                  :param timeout: 最大等待时间
                  :return:
                  """
                  try:
                      elements = WebDriverWait(self.driver,timeout).until(EC.presence_of_all_elements_located(locator))
                      return elements
                  except:
                      print(f"元素{locator}没找到")
                      return False
          
              def click(self,locator):
                  """
                  点击元素
                  :return:
                  """
                  element = self.find_element(locator)
                  try:
                      element.click()
                  except Exception as msg:
                      print(msg)
          
              def send_keys(self, locator, text):
                  """
                  输入
                  :param locator: 定位器,元组
                  :param text: 需要输入的文本
                  :return:
                  """
                  element = self.find_element(locator)
                  try:
                      element.clear()
                      element.send_keys(text)
                  except Exception as msg:
                      print(msg)
          
              def is_text_in_element(self, locator, text, timeout=10):
                  """
                  判断文本是否在元素的文本中,如果在,返回True,如果不在返回False
                  :param locator: 定位器,元组
                  :param text: 文本
                  :return:
                  """
                  try:
                      result = WebDriverWait(self.driver, timeout).until(EC.text_to_be_present_in_element(locator,text))
                      return result
                  except:
                      return False
          
              def is_value_in_element(self,locator, value, timeout=10):
                  """
                  判断value值是否是元素value属性对应的值,如果是,返回True,否则返回False
                  :param locator: 定位器
                  :param value: 文本
                  :param timeout:
                  :return:
                  """
                  try:
                      result = WebDriverWait(self.driver, timeout).until(EC.text_to_be_present_in_element_value(locator,value))
                      return result
                  except:
                      return False
          
              def is_selected(self,locator):
                  """
                  判断元素是否被选中:如果选中,返回True,否则返回False
                  """
                  element = self.find_element(locator)
                  try:
                      result = element.is_selected()
                      return result
                  except:
                      return False
          
          
          if __name__ == '__main__':
              import time
              driver = open_browser("chrome")
              base = Base(driver)
              base.open_url("http://www.baidu.com/")
              # 搜索框定位器
              search_loc = ("id", "kw1")
              # 按钮定位器
              button_loc = ("id", "su1")
              value = "百度一下"
              # 新闻链接定位器
              news_loc = ("link text", "新闻1")
              text = "新闻"
              # # 搜索框输入
              # base.send_keys(search_loc,"周琦")
              # # 点击百度一下
              # base.click(button_loc)
              # 判断新闻链接
              print(base.is_text_in_element(news_loc, text))
              # 判断百度一下按钮
              print(base.is_value_in_element(button_loc, value))
          
              time.sleep(3)
              base.close()
          

      • 工具类

        • operation_excel.py

          """
          1.学习目标
              掌握封装Excel表格  工具类  功能读取表格
          2.操作步骤(语法)
              将表格的数据读取成[{},{}...]
              字典的键:表格中的第一行
              字典的值:表格中的其他行
              excel数据    Python数据
              1            str
              2            整数
              3            日期
              4            布尔值
          3.需求
          """
          import xlrd
          
          # 创建工具类,操作Excel表格
          class OperationExcel:
              def __init__(self,filename):
                  """
                  初始化类,每次传入文件名
                  :param:filename: 文件路径+文件名
                  """
                  self.table = xlrd.open_workbook(filename)
          
              def get_data_by_index(self,index=0):
                  """
                  通过索引读取数据
                  :param:index 索引值
                  :return:
                  """
                  sheet = self.table.sheet_by_index(index)
                  return self._get_data_info(sheet)
          
              def get_data_by_name(self,name):
                  """
                  通过表名读取数据
                  :param name:
                  :return:
                  """
                  sheet = self.table.sheet_by_name(name)
                  return self._get_data_info(sheet)
          
              def _get_data_info(self,sheet):
                  """
                  获取数据的详情
                  :param sheet:
                  :return:
                  """
                  keys = sheet.row_values(0)  # 将表格的第一行作为字典的键
                  rows = sheet.nrows  # 获取表中的总行数
                  cols = sheet.ncols  # 获取表中的总列数
                  data_list = []  # 放置读取的数据
                  for row in range(1, rows):  # 遍历行
                      value_list = []  # 放置每行的数据
                      for col in range(cols):  # 遍历列
                          value = self._read_cell(sheet, row, col)
                          value_list.append(value)
                      tmp = zip(keys, value_list)  # 使用zip函数组合键和值
                      data_list.append(dict(tmp))  # 将字典添加到列表中
                  return data_list
          
              def _read_cell(self,sheet,row,col):
                  """
                  处理单元格数据类型
                  :param sheet:
                  :return:
                  """
                  # sheet = self.table.sheet_by_index(0)
                  cell = sheet.cell_value(row,col)  # 单元格数据
                  cell_type = sheet.cell_type(row,col)  # 获取单元格的数据类型
                  if cell_type == 1:  # 当单元格数据类型为str
                      cell = cell  # 不对数据做任何处理
                  elif cell_type == 2 and cell % 1 == 0:  # 当单元格数据类型为整数时
                      cell = int(cell) # 转为int类型
                  elif cell_type == 4:  # 当单元格数据类型布尔值
                      cell = True if cell == 1 else False  # 三目运算符
                  return cell
          
          
          if __name__ == '__main__':
              oper = OperationExcel("../data/login_data.xls")
              # data = oper.get_data_by_index()
              data = oper.get_data_by_name("Sheet1")
              print(data)

        • xxxx.py

    • page文件夹 --一个页面就是一个.py文件

      • 封装页面的表现层和操作层---继承base.py

      • login_page.py # 登录页面

        """
        login_page.py
        封装页面的表现层
        封装页面的操作层
        需要继承base类
        """
        from common.base import Base
        
        login_url = "http://ecshop.itsoso.cn/user.php"  # 页面地址
        
        
        class LoginPage(Base):
            """封装表现层: 制作定位器"""
            username_loc = ("name", "username")  # 用户名输入框
            password_loc = ("name", "password")  # 密码输入框
            remember_loc = ("id", "remember")  # 记住密码复选框
            submit_loc = ("class name", "us_Submit")  # 立即登录按钮
        
            """
            封装操作层: 元素操作
            每一个元素的操作,都写成一个方法
            低耦合性:
                打电话:
                    1.拿起手机
                    2.拨号
                    3.通话
                发短信:
                    1.拿起手机
                    2.编辑短信
                    3.发送
                封装方法:
                1.拿起手机,2.拨号,3.通话,4编辑短信,5.发送
            """
            def input_username(self,text):
                """输入用户名"""
                self.send_keys(self.username_loc,text)
        
            def input_password(self,text):
                """输入密码"""
                self.send_keys(self.password_loc,text)
        
            def click_remember(self):
                """点击记住密码"""
                if self.is_selected(self.remember_loc):
                    pass
                else:
                    self.click(self.remember_loc)
        
            def click_submit(self):
                """点击立即登录"""
                self.click(self.submit_loc)
        
        
        if __name__ == '__main__':
            from common.base import open_browser
            import time
            driver = open_browser()
            login = LoginPage(driver)  # 实例化loginpage
            login.open_url(login_url)
            username = "诸葛亮_1"
            password = "Test123456"
            login.input_username(username)  # 输入用户名
            login.input_password(password)  # 输入密码
            login.click_remember()  # 点击记住密码
            login.click_submit()  # 点击立即登录
            time.sleep(3)   # 观察代码执行效果
            login.close()
        
        

      • register_page.py # 注册页面

    • script文件夹 -- 测试用例

      • 封装页面的业务层(测试用例)

      • 测试用例调用page文件夹中的类

        """
        test_login.py
        封装业务层
        
        common    page      script
        
        """
        # 调用page文件夹中的login_page.py
        from page.login_page import LoginPage, login_url
        from common.base import open_browser
        import unittest
        
        
        class TestLogin(unittest.TestCase):
            def setUp(self):
                driver = open_browser()  # 打开浏览器
                self.login = LoginPage(driver)  # 实例化LoginPage
                self.login.open_url(login_url)  # 打开登录地址
        
            def test_login(self, username,password):
                """
                测试登录:
                用例的操作步骤
                """
                # 1.输入用户名
                self.login.input_username(username)
                # 2.输入密码
                self.login.input_password(password)
                # 3.点击登录
                self.login.click_submit()
                """缺失预期结果"""
        
        
        
        if __name__ == '__main__':
            login = TestLogin()
            login.test_login("诸葛亮_1","Test123456")
        
        
        

    • data存放测试数据

    • report存放测试报告

3.selenium ide(了解)

  • 下载

    • 下载 火狐浏览器的一个插件

    • 菜单---->附加组件---->搜索selenium ide---->选第一个下载

  • 录制

    • 打开selenium ide

      • 创建新项目

      • 打开已有项目

      • 关闭selenium

      • 记录并创建新项目

    • 在地址栏中输入被测网址

    • 点击REC---REC图标为红色

    • 操作被测网址

    • 点击停止记录Pause

    • 保存

  • 回放

    • 点击运行当前测试用例/运行所有测试用例

    • 将时间调到最慢

  • 导出代码

    • 在测试用例上右键---->选择Export

    • 选择语言---Python

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值