精华内容
下载资源
问答
  • Python selenium —— selenium自动化测试成神之路

    万次阅读 多人点赞 2016-09-17 00:33:04
    很多都是明显的语法问题,一问方知,今天刚刚学selenium,之前也没有语法基础,没学过Java,没学过Python,就跑来搞selenium,想玩自动化。每当看到这样的同学,总是很想吐槽。今天博主也不是想要吐槽,只

    Python selenium —— selenium与自动化测试成神之路

    忽然想谈谈自动化的学习路径,因为发现很多人总是急于求成,不懂该如何学习。

    在群里总是会遇到很多人问低级问题,写了一个selenium脚本,却执行失败,跑到群里来问,大神,这里为什么会报错?很多都是明显的语法问题,一问方知,今天刚刚学selenium,之前也没有语法基础,没学过Java,没学过Python,就跑来搞selenium,想玩自动化。每当看到这样的同学,总是很想吐槽。今天博主也不是想要吐槽,只是想跟大家谈谈我认为的正确的自动化学习路径。

    1. 首先要搞明白几个问题

    本来想写一些东西,但忽然发现虫师已经对这个问题总结很到位了,所以我也就不想多说什么,放上链接,学自动化测试之前,先去看看吧

    在做自动化测试之前你需要知道的

    自动化是用机器代替手工做一些事情。作为一个测试人员,做自动化一般是指接口自动化与UI自动化。(接口也是指对外的部分,通过各种协议,各系统或模块之间交流的接口。)接口性价比更高,但不代表UI自动化没有价值。

    2. 编程语言基础

    很多想学自动化测试的同学都忽略了编程语言的重要性。很大一部分测试人员不懂编程,也不想学编程,但如果你想要学习自动化,那编程是必须的!

    你可能会觉得QTP就不需要编程,录制回放就可以了。这是大错特错的,QTP要想玩的溜,VB是必须的。selenium想要玩的溜,Java或者Python是必须的!(selenium并不局限于这两种语言,但是你用其他语言玩,别怪我没有提醒你,你会遇到很多麻烦,而且还找不到人能跟你交流,你的成长速度会慢得多)

    很多人没有学语言,直接上来搞selenium,我认为这是一种本末倒置的行为,没有语言基础,想学会自动化,是走到了弯路上,到达目的地时间要更久。

    那么学Java还是Python?这个要取决于你对那种语言更熟悉一些,同时要看测试团队所使用的语言,如果团队用Java,那你就学Java。如果你既没有语言基础,测试团队也没有指定的语言,那么我建议你学Python,Python相对Java更简单,学习成本要低一些。

    确定了要学习的语言,博主便推荐一些学习资料:

    1. 如果你一点语言基础都没有,那么我推荐你先把《笨办法学Python》中的前45个练习照着敲一遍。(注意:必须得一个个手敲,代码学习重在实践),有个网站,英文版笨办法,推荐给你Learn Python The Hard Way,英文不好?OK,给你个中文版笨办法学Python 下载

    2. 如果你有学过一门语言,了解基本的数据结构和判断、循环之类的,或者你刚刚完成步骤0的练习,我推荐你这个阶段学习Python语言基础。这个阶段有好几本好书,当然,你只需要其中的一本就足够了:《Python核心编程》、《Python基础教程》、《Python简明教程》、《Python入门指南》、《Head First Python》等,这个你去百度便能百度到很多,去京东淘宝逛一逛,看销量最多的也便可知。当然,我推荐你《Python核心编程》,建议买本纸质书。至于其中的内容,你学习完成主干部分即可,最后面的几章关于网络编程、线程与进程的,可以先不看,当遇到这样的问题,可以再来补充这方面的知识。

    3. 跟着廖雪峰的网站学也是可以的 廖雪峰Python教程

    好了,这两个阶段完成之后,我认为你做好了学习selenium的准备,可以开始学习selenium了。

    3. selenium学习,脚本编写

    接下来终于要到学习selenium的时候了,在这个时候,我需要你先去搞清楚几个问题:

    • selenium到底是什么?
    • selenium家族成员,selenium的结构组成。
    • selenium支持的语言,浏览器。selenium操作浏览器需要依赖的驱动,驱动版本与浏览器版本的关系。

    然后还需要再简单学习一些前端的知识:

    • HTML(网页结构,各种标签)
    • Xpath(基本的定位要了解,轴的内容可以在有一定基础之后再学)
    • CSS(简单了解)
    • JavaScript(简单了解)
    • Firebug(开发者工具)的使用(这个经常会用到,必须熟悉,可在selenium学习中逐渐深入)
    • 网络基础知识

    接下来就是学习selenium了,入门推荐虫师的《Selenium2自动化测试实战–基于Python语言》,这本书比较基础,用来入门再合适不过,期间也可混杂着看一些博客,比如我的博客^_^,会给你不少帮助。

    同时不要光看,一定要动手自己写代码,找一个网站,先练基础元素的定位与操作,推荐一个练手网站:http://sahitest.com/demo/index.htm

    基本定位方式熟悉了,就是要对一个正式的网站进行实践了,你可以用你们公司的网站,也可以用某些门户网站,比如58、赶集等等,可以用selenium做一个小爬虫,爬取网站上的一些信息。这个过程中你会遇到各种坑,各种诡异的事情,不要怕,你一定要相信这些坑,前辈们早已替你趟过了。

    一定要善用百度、Google,搞IT的,不会翻墙,不会百度,简直没有资格叫自己是XX工程师,Google的重要性我不想再多言,起码GitHub博客,百度的爬虫是爬不到的

    4. 执行测试,脱离脚本阶段

    恭喜你,你能写脚本了,能写小爬虫从网站上爬东西了,接下来,你得真正开始执行测试了。

    在这个阶段,你必须学习的是Python的doctest和unittest

    学习怎么用断言来添加检查点。

    同时,你要学习怎么将代码中公共的部分抽出来,把测试和业务分离开,学习PageObject思想。

    用testsuite来组织你的测试用例,并学习HTMLTestRunner下载,学习怎么输出报告。

    5. 参数化、配置、日志、简单框架搭建

    你已经能够用unittest组织用例,并输出报告了。这时候,你需要让你的测试更像个样子。

    该学习参数化了,学习xlrd、xlwt操作excel文件,学习xml库操作xml文件,来配置你的数据源,实现参数化。

    还需要学习configParser、pyyaml模块,进行配置文件的操作,将用例中的配置提取出来,写在配置文件里,这样要修改起来就容易多了。

    然后还得学习logging库,学会怎么记录日志,写你自己的日志模块,在用例里加上日志记录。

    到了这儿,基本上,就像个样子了。但是不能把这些东西放在一起,你就需要搭建一个轻量级的小框架,来分层组织你的代码与其他文件,可以参照我的博客简单分享一个轻量级自动化测试框架目录结构设计,还有博主的专栏 从零搭建一个自动化测试框架,教你怎么一步步搭建自己的框架。这下你就能把所有的东西分门别类管理起来,终于有点专业的样子了。

    6. 自动执行,自动发送报告

    简单的框架搭建好了,你也能够每次执行testsuite便可以得到测试报告了。但这时,你又不满足了。

    是的,你应该让它自动执行,自动把报告发到你手里(或者你老大手里,当然,未成熟前不建议这么做)。

    你该学习Jenkins了。别丧气,这个玩意很简单,你也只需要简单的配置便可以让你的测试任务在Jenkins上跑起来了。

    还有,要自动发报告,简单学习下smtplib模块吧,它能让你的报告以邮件的形式发送到团队成员的手中。

    7. 高级货,平台?分布式?界面?

    是不是很有成就感了,QQ群里也有了很多人叫你大神。满满的虚荣心有木有?

    不过,你就满足于这些吗?

    当然不,还有更多想要做的。

    UI的用例执行太慢了,整个分布式的执行怎么样?selenium的grid还没有研究呢。我可以用一台机器控制,让多台机器同时执行我的测试,想想简直碉堡了对不对。

    还能怎么玩?搞个界面怎么样?学学Django、flask、web2py、web.py?挑一个,搞个界面,管理用例,管理测试执行,如何?

    再搞搞数据分析,配个数据库,拿到历史执行数据,搞出来个报表怎么样?

    看看request、suds、socket,把接口测试整进测试平台,怎么样?

    单元测试?嘿嘿嘿,小case。

    再集成个性能测试工具,一块搞到平台里去怎么样?

    8. 现在,大神,可以拿你的平台去卖钱了

    恭喜你,你绝对已经成神了。

    你不仅仅是一个自动化测试工程师了,你已经是一个全栈开发工程师了。还有什么能难得到你的?

    当然,别嘲笑我,博主也是在慢慢往上爬,这些也只是我个人的一些脑洞,一些想法,如果你也有什么想法,可以和博主多交流交流。

    谨以此文,向广大的初学者指点一条博主认为不错的路径,具体你的学习方式、学习过程,见仁见智吧。


    更多关于python selenium的文章,请关注我的CSDN专栏:Python Selenium自动化测试详解

    展开全文
  • 基于 SELENIUM自动化测试架构 非常感谢各位查阅本篇文章,笔者在此感谢各位。 目前市面上有分门别类的自动化测试工具,这篇文章将讨论开源自动化测试工具 Selenium的使用,以及围绕该工具进行自动化测试的...

    基于 SELENIUM 的自动化测试架构

    非常感谢各位查阅本篇文章,笔者在此感谢各位。

    目前市面上有分门别类的自动化测试工具,这篇文章将讨论开源自动化测试工具 Selenium的使用,以及围绕该工具进行自动化测试的理念、方案以及测试架构的构建。

    1. 工具的使用

    1.1 Selenium 介绍

    Selenium是开源的自动化测试工具,它主要是用于Web 应用程序的自动化测试,不只局限于此,同时支持所有基于web 的管理任务自动化。

    Selenium官网的介绍如下:

    Selenium is a suite of tools to automate web browsers across many platforms.

    • runs in many browsers and operatingsystems
    • can be controlled by many programming languages and testing frameworks.

    Selenium 是用于测试 Web 应用程序用户界面 (UI) 的常用框架。它是一款用于运行端到端功能测试的超强工具。您可以使用多个编程语言编写测试,并且 Selenium 能够在一个或多个浏览器中执行这些测试。

    Selenium 经历了三个版本:Selenium 1,Selenium 2 和 Selenium 3。Selenium 也不是简单一个工具,而是由几个工具组成,每个工具都有其特点和应用场景。

    Selenium 诞生于 2004 年,当在 ThoughtWorks 工作的 Jason Huggins 在测试一个内部应用时。作为一个聪明的家伙,他意识到相对于每次改动都需要手工进行测试,他的时间应该用得更有价值。他开发了一个可以驱动页面进行交互的 Javascript 库,能让多浏览器自动返回测试结果。那个库最终变成了 Selenium 的核心,它是 Selenium RC(远程控制)和 Selenium IDE 所有功能的基础。Selenium RC 是开拓性的,因为没有其他产品能让你使用自己喜欢的语言来控制浏览器。这就是 Selenium 1。

    然而,由于它使用了基于 Javascript 的自动化引擎,而浏览器对 Javascript 又有很多安全限制,有些事情就难以实现。更糟糕的是,网站应用正变得越来越强大,它们使用了新浏览器提供的各种特性,都使得这些限制让人痛苦不堪。

    在 2006 年,一名 Google 的工程师, Simon Stewart 开始基于这个项目进行开发,这个项目被命名为 WebDriver。此时,Google 早已是 Selenium 的重度用户,但是测试工程师们不得不绕过它的限制进行工具。Simon 需要一款能通过浏览器和操作系统的本地方法直接和浏览器进行通话的测试工具,来解决Javascript 环境沙箱的问题。WebDriver 项目的目标就是要解决 Selenium 的痛点。

    到了 2008 年,Selenium 和 WebDriver 两个项目合并。Selenium 有着丰富的社区和商业支持,但 WebDriver 显然代表着未来的趋势。两者的合并为所有用户提供了一组通用功能,并且借鉴了一些测试自动化领域最闪光的思想。这就是 Selenium 2。

    2016 年,Selenium 3 诞生。移除了不再使用的 Selenium 1 中的 Selenium RC,并且官方重写了所有的浏览器驱动。

    1.2 Selenium 工具集

    • Selenium IDE

      Selenium IDE (集成开发环境) 是一个创建测试脚本的原型工具。它是一个 Firefox 插件,实现简单的浏览器操作的录制与回放功能,提供创建自动化测试的建议接口。Selenium IDE 有一个记录功能,能记录用户的操作,并且能选择多种语言把它们导出到一个可重用的脚本中用于后续执行。

    • Selenium RC

      Selenium RC 是selenium 家族的核心工具,Selenium RC 支持多种不同的语言编写自动化测试脚本,通过selenium RC 的服务器作为代理服务器去访问应用从而达到测试的目的。

      selenium RC 使用分Client Libraries 和Selenium Server。

      • Client Libraries 库主要主要用于编写测试脚本,用来控制selenium Server 的库。
      • Selenium Server 负责控制浏览器行为,总的来说,Selenium Server 主要包括3 个部分:Launcher、Http Proxy、Core。
    • Selenium Grid

      Selenium Grid 使得 Selenium RC 解决方案能提升针对大型的测试套件或者哪些需要运行在多环境的测试套件的处理能力。Selenium Grid 能让你并行的运行你的测试,也就是说,不同的测试可以同时跑在不同的远程机器上。这样做有两个有事,首先,如果你有一个大型的测试套件,或者一个跑的很慢的测试套件,你可以使用 Selenium Grid 将你的测试套件划分成几份同时在几个不同的机器上运行,这样能显著的提升它的性能。同时,如果你必须在多环境中运行你的测试套件,你可以获得多个远程机器的支持,它们将同时运行你的测试套件。在每种情况下,Selenium Grid 都能通过并行处理显著地缩短你的测试套件的处理时间。

    • Selenium WebDriver

      WebDriver 是 Selenium 2 主推的工具,事实上WebDriver是Selenium RC的替代品,因为Selenium需要保留向下兼容性的原因,在 Selenium 2 中, Selenium RC才没有被彻底的抛弃,如果使用Selenium开发一个新的自动化测试项目,那么我们强烈推荐使用Selenium2 的 WebDriver进行编码。另外, 在Selenium 3 中,Selenium RC 被移除了。

    1.3 Selenium WebDriver 的使用

    接下来的内容,我们将会主要讨论本文的核心重点, Selenium WebDriver 的使用。 Selenium WebDriver 是从 Selenium 2 开始使用并流行, 在 Selenium 3 中得到进一步发展的工具,是当前 Selenium 的最核心的工具。WebDriver 具有清晰面向对象 API,能以最佳的方式与浏览器进行交互。

    Selenium WebDriver 就好比是一个懂浏览器的司机,它可以在浏览器的网页上行走,走到网页内容的任何地方,可以参观网页的任何地方,并且和网页进行交互。那么作为测试工程师,如果想和这样的一个司机打交道,就必须要掌握和这样的司机打交道的技能。

    • 学习司机会使用的语言,并使用该语言,以及合适的沟通工具与司机进行交流
      • Java
      • Python
      • C#
      • JavaScript
      • PHP
      • Ruby
    • 给司机找到合适的浏览器,以便司机在浏览器上行走。
      • 支持多种浏览器,包括 Chrome,Firefox,IE,Edge,Safari,Opera 等

    Selenium WebDriver 的使用主要分为两个场景:

    • 懂浏览器的司机,WebDriver 类
      • 用 WebDriver 提供的模板,制造一个司机。
      • WebDriver 的第一个应用场景,就是这个司机的各种能力,包括但不限于以下的部分
        1. 用浏览器打开指定的 URL
        2. 清理浏览器的Cookie
        3. 在浏览器中寻找页面元素(Web Element)
        4. 查找单个的指定元素
        5. 查找一组有共同属性的元素,并进行遍历等。
        6. 控制浏览器的基本操作:
          • 前进: forward()
          • 后退: backward()
          • 刷新: refresh()
          • 关闭: close()
          • 最大化: maximize_window()
          • 弹窗: switch_to_alert()
        7. 返回浏览器的属性
          • current_url
          • title
        8. 执行 JavaScript 脚本
    • 在浏览器中找到的元素,WebElement 类
      • 司机在浏览器中找到页面元素以后,对它做的任何操作,都是 WebDriver 的第二个主要的场景
        1. 点击该元素: click()
        2. 清除该元素原有的文字: clear()
        3. 给该元素填写新的文字: send_keys()
        4. 获取该元素的文字: text
        5. 获取该元素的指定属性: get_attribute()
        6. 对该元素进行二次加工
          • 构成 frame 并切换进去: switch_to.frame(元素)
          • 构成 select 并进行操作: Select(元素).select_by_value()

    1.4 Selenium 环境搭建

    Selenium 的环境搭建基本上分为三个部分:

    1. 安装编程语言以及IDE(集成编程环境),用来操作 WebDriver
    2. 安装 Selenium WebDriver,实现浏览器的测试
    3. 安装浏览器,和指定的驱动,完成自动化测试的执行

    接下来分别用目前市面上主流的 Java 和 Python 环境进行搭建。

    • Java 版本

      1. 安装 Java 语言,即 JDK。推荐 1.8 的版本。

      2. 安装 IDE,推荐 JetBrains IDEA Community Edition,这款是目前主流的 Java 开发工具,而且社区版是免费使用的,拥有出色的用户交互,以及使用界面,完全能够应对一般的自动化测试的编程。当然如果你更加熟悉Eclipse,也是可以使用的。

      3. 安装 Selenium,推荐使用 Maven 直接引入依赖。当自动化测试作为团队共同的解决方案,而不是一个人单独维护的方案的时候,团队需要统一的 Selenium 版本以及共同的 API 操作,Maven 的使用,无疑简化了项目的难度,很好的解决了此类问题。

        <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java -->
        <dependency>
         <groupId>org.seleniumhq.selenium</groupId>
         <artifactId>selenium-java</artifactId>
         <version>3.3.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-remote-driver -->
        <dependency>
         <groupId>org.seleniumhq.selenium</groupId>
         <artifactId>selenium-remote-driver</artifactId>
         <version>3.3.1</version>
        </dependency>

        当然,你也可以直接下载 Selenium Standalone Server,并且手工引用 Jar 包到项目中。最新版3.3.1的下载地址:3.3.1

      4. 安装 浏览器和浏览器的驱动。

      以上的步骤,便完成了 Java + Selenium 的环境搭建。

    • Python 版本

      1. 安装 Python 语言。

        Python 目前并行了两套版本,2.x 和 3.x。如果你之前没有 Python 的使用经验,建议使用 Python 3.x 版本。两套版本互相不兼容,并且 Python 从 3.5(含)开始,不再支持 Windows XP 系统,请注意。

      2. 安装 Python IDE,推荐 JetBrains Pycharm Community Edition。

      3. 安装 Selenium,推荐使用 pip 的方式直接安装。在命令行下,直接输入:

        
        # 在Selenium 3 发布之前,可以用下面命令直接装selenium
        
        
        # -U = --upgrade 升级安装
        
        
        # 自动安装最新版
        
        
        # 目前3.0发布以后,这个命令直接安装 3.3.1 的最新版
        
        pip install -U selenium
        
        
        # 如果要装2.53.6版本
        
        pip install selenium==2.53.6

        如果你处于没有外网的情况下,可以采用源码解压安装,前往https://pypi.python.org/pypi/selenium下载最新版的PyPI版本的Selenium,解压后执行:

        python setup.py install
      4. 安装 浏览器和浏览器的驱动。

        以上的步骤,便完成了 Python + Selenium 的环境搭建。

    1.5 Selenium 编程

    通过前面的介绍,我们知道 Selenium 支持多种语言,并且推荐使用面向对象的方式进行编程。接下来我们将着重介绍如何使用面向对象的方式进行编程。

    在面向对象的理念看来,任何的编码,都是由对象而来的,这里也不例外。和之前介绍 WebDriver 时候的描述对应,我们需要用到两种主要的类,并将其实例化。

    • WebDriver 类:主要靠直接实例化该类为对象,然后用其对象直接调用该类的方法和属性
    • WebElement 类:主要通过 WebDriver 类实例化的对象,通过对页面元素的查找,得到 WebElement 类的对象,然后调用该类的方法和属性。

    具体的使用如下,以 Java 语言 和 火狐浏览器为例

    // 声明 Web司机,司机是一个火狐类的对象
    // 需要用 new 关键字来实例化对象, () 代表构造方法
    WebDriver driver = new FirefoxDriver();
    
    // Web司机去打开网站
    driver.get("http://demo.ranzhi.org");
    
    // 线程停止 3000 毫秒,使得 Web司机有足够的时间打开网址
    Thread.sleep(3000);
    
    // 选择 用户名 密码 并依次输入 demo 和 demo (用户名和密码都是 demo)
    weAccount = driver.findElement(By.cssSelector("#account"));
    weAccount.clear();
    weAccount.sendKeys("demo");
    
    wePassword = driver.findElement(By.cssSelector("#password"));
    wePassword.clear();
    wePassword.sendKeys("demo");
    
    // 选择 登录 按钮,并点击 click
    driver.findElement(By.cssSelector("#submit")).click();
    Thread.sleep(5000);

    上述代码中,使用了一个 WebDriver 类 的对象,即第3行,声明了该类的对象,并赋值给变量 driver,接着变量 driver 作为 WebDriver 类的对象,使用了多个 WebDriver 类的方法。

    • get(url): 第6行,打开网址
    • findElement(by, selector): 第12、16、21行都使用了该方法,同时通过对该方法的调用,分别各产生了一个 WebElement类的对象,weAccountwePassword和最后一个匿名的对象,并通过产生的三个对象,调用 WebElement 类的方法
      • clear():清理页面元素中的文字
      • sendKeys(text):给页面元素中,输入新的文字
      • click():鼠标左键点击页面元素

    正是通过这样的面向对象的方式,产生 Web司机(WebDriver类的对象),并且通过 Web司机不懈的努力,寻找到各种 Web元素(WebElement类的对象)进行操作,这样便实现了 Selenium WebDriver 作为一款出色的浏览器测试工具,进行浏览器UI界面的自动化测试的代码编写和用例执行。

    上述代码,也同样可是使用 Python 作为编程语言进行操作,如下所示:

    # 声明一个司机,司机是个Firefox类的对象
    driver = webdriver.Firefox()
    
    # 让司机加载一个网页
    driver.get("http://demo.ranzhi.org")
    
    # 给司机3秒钟去打开
    sleep(3)
    
    # 开始登录
    # 1. 让司机找用户名的输入框
    we_account = driver.find_element_by_css_selector('#account')
    we_account.clear()
    we_account.send_keys("demo")
    
    # 2. 让司机找密码的输入框
    we_password = driver.find_element_by_css_selector('#password')
    we_password.clear()
    we_password.send_keys("demo")
    
    # 3. 让司机找 登录按钮 并 单击
    driver.find_element_by_css_selector('#submit').click()
    sleep(3)

    常用的重点编程对象有如下几种:

    • WebDriver 类

      • get(url): 打开web页面
      • findElement(by, selector): 查找一个页面元素
      • 配合浏览器的开发者工具(推荐 Chrome Developer Tools),有8中方式定位元素:
        • id:元素标签的 id
        • css selector:元素标签的 selector
        • xpath:元素标签的 XPath
        • link text:元素标签的完整文字
        • name:元素标签的 name
        • class name:元素标签的 class name
        • tag name:元素标签的 tag name
        • partial link text:元素标签的部分文字
    • findElements(by, selector):查找一组具有同一属性的页面元素,方式同上。

      • deleteAllCookies():清理 Cookies
      • executeJs(js):执行 JavaScript
      • quit(): 退出浏览器
      • getTitle():当前浏览器的标题属性
      • getCurrentUrl():获取当前浏览器的 URL
    • WebElement 类

      • click():点击改元素

      • clear():清除当前的文本

      • sendKeys(text):给当前的元素输入文字

      • getAttribute(attribute):获取当前元素的某一种属性

      • getText():获取当前元素的文字属性

      • isDisplayed():获取当前元素的 Displayed 属性

      • Select:针对 <select>元素进行的操作

      • selectByValue(value)

      • selectByIndex(index)

        // 找到该 <select> 元素 we
        WebElement we = driver.findElement(by, selector);
        // 使用该元素,实例化一个 Select 类的对象 s
        Select s = new Select(we);
        s.selectByValue(value);
        // 或者用index
        s.selectByIndex(value)
      • 鼠标事件,有关鼠标的操作,不只是单击,有时候还要做右击、双击、拖动等操作。这些操作包含在ActionChains类中。

      • contextClick():右击

      • douchClick():双击
      • dragAndDrop():拖拽
      • moveToElement():鼠标停在一个元素上
      • clickAndHold():按下鼠标左键在一个元素上
    • Frame: 针对<iframe>元素标签进行的操作

      很多的页面中,都包含有内联框架(iframe),那么如果需要获取到其内部的元素并进行操作,必须首先切换到该内联框架中,当操作完成以后,再退出到最外层的网页中

      // 找到该内联框架的元素 
      WebElement we = driver.findElement(by, selector);
      // 利用WebDriver 的对象driver,切换到该内联框架中
      driver.switchTo().frame(we);
      // TODO: 进行各种操作
      // 退出该内联框架,返回到外层的网页中
      driver.switchTo().defaultContent();

    2. 理念与方案

    在第一部分,工具的使用中,我们重点介绍了 Selenium 工具的编程,但是这样其实对于自动化测试来讲,还远远不够。自动化测试的重点,其实依旧是测试用例的编写和执行,要求代码中,具备测试用例的属性;同时要求测试的代码能够很好的组织起来,通过抽取和分离的理念,实现良好的测试。主要达到以下的几个目的:

    • 具备测试用例的属性

      测试代码,可以轻松的具备测试用例的属性,主要包括测试前置条件、清理操作、和断言(检查)。

    • 避免重复代码的编写和复制

      通过模块化拆分页面功能,避免 WebDriver类的重复实例化和调用,也避免同样的测试步骤,多次的编写和复制

    • 测试数据单独存放

      测试代码中不需要包含需要输入的测试数据,而是把测试数据单独存放在 文本文件,或者数据库中。

    • 封装底层的测试工具

      对 Selenium WebDriver 这种第三方的工具,进行封装起来,避免代码中直接调用

    • 必须使用源代码管理工具

      无论是否是一人团队,源代码管理工具的使用都是积极地和必要的,推荐使用 Git 。

    接下来的描述,将会对上述的理念依次进行讲解,实现自动化测试的方案。

    2.1 使用单元测试框架

    在第一部分,我们对 Selenium WebDriver 的使用,仅仅停留在让网页自动的进行操作的阶段,并没有对任何一个步骤进行“检查”。当然,这样没有“检查”的操作,实际上是没有测试意义的。那么第一项,我们需要解决的便是“检查”的问题。

    所谓“检查”,实际上就是断言。对需要检查的步骤操作,通过对预先设置的期望值,和执行结果的实际值之间的对比,得到测试的结果。在这里,我们并不需要单独的写 if 语句进行各种判定,而是可以使用编程语言中对应的单元测试框架,即可解决好此类问题。

    目前 Java 语言主流的单元测试框架有 JUnit 和 TestNG。Python 语言主流的单元测试框架有 unittest 。本小节的内容,主要介绍 TestNG 和 unittest 的使用,探讨单元测试框架如何帮助自动化测试。

    • TestNG

      接下来我们将会使用Java语言的TestNG框架展开“检查”。TestNG为我们在项目测试中常用到的单元测试框架,很多程序员的理想套件,通过注解(annotation)的方式进行操作。

      TestNG提供了@BeforeMethod@AfterMethod,在每个测试函数调用之前/后都会调用。

      • @BeforeMethod: Method annotated with @BeforeMethod executes before every test method.
      • @AfterMethod: Method annotated with @AfterMethod executes after every test method.

      如果在测试之前有些工作我们只想做一次,用不着每个函数之前都做一次,那就用下面两个来标注:

      • @BeforeTest: 在第一个 test method 开始执行前,执行。
      • @AfterTest: 在最后一个 test method 执行后再执行。

      接下来我们用具体的代码示例,解释单元测试框架的使用

      • TestNG 框架图

      TestNG单元测试框架示意图.png

      • TestNG 断言
      方法 Method检查条件
      assertEquals(a, b [, msg])a == b,msg可选,用来解释失败的原因
      assertNotEquals(a, b [, msg]a != b,msg可选,用来解释失败的原因
      assertTrue(x [, msg])x 是真,msg可选,用来解释失败的原因
      assertFalse(x [, msg])x 是假,msg可选,用来解释失败的原因
      assertIsNot(a, b [, msg])a 不是 b,msg可选,用来解释失败的原因
      assertNull(x[, msg])x 是null,msg可选,用来解释失败的原因
      assertNotNull(x[, msg])x 不是null,msg可选,用来解释失败的原因
      • TestNG 的引入

      这里我们依旧使用 Maven 的方式,引入 TestNG 到项目中。

      <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>6.8</version>
      </dependency>

      • TestNG 的使用
      /**
       * Created by Linty on 1/8/2017.
       * 使用 @BeforeTest @AfterTest 进行测试框架操作
       * 如果直接运行整个测试,运行步骤如下
       * 首先运行 @BeforeTest
       * 然后运行 test01ChangeLanguage
       * 接着运行 test02LogIn
       * 最后运行 @AfterTest
       */
      public class RanzhiMainTest {
          // 声明两个全局变量,每个方法都可以用下面的变量。
          private WebDriver baseDriver = null;
          private String baseUrl = null;
          /**
           * 测试登录
           * 需要用 @Test 注解进行标注
           * 这样 不用main()方法 便可直接运行测试
           *
           * @throws InterruptedException
           */
          @Test
          public void test02LogIn() throws InterruptedException {
              WebDriver driver = this.baseDriver;
              driver.get(this.baseUrl);
              Thread.sleep(2000);
              driver.findElement(By.id("account")).sendKeys("admin");
              driver.findElement(By.id("password")).sendKeys("123456");
              driver.findElement(By.id("submit")).click();
              // 点击登录按钮后,需要等待浏览器刷新
              Thread.sleep(2000);
              String expectedUrl = this.baseUrl + "sys/index.html";
              // driver.getCurrentUrl() -- 获取当前的浏览器URL
              Assert.assertEquals(driver.getCurrentUrl(), expectedUrl);
          }
          /**
           * 测试切换语言
           * 把系统语言切换成 English
           * 然后查询 语言的按钮 是不是变成了 English
           * @throws InterruptedException
           */
          @Test
          public void test01ChangeLanguage() throws InterruptedException {
              WebDriver driver = this.baseDriver;
              driver.get(this.baseUrl);
              Thread.sleep(2000);
              // 点击语言按钮
              driver.findElement(By.cssSelector("#langs > button")).click();
              Thread.sleep(500);
              // 用Css Selector 选择 英文
              driver.findElement(By.cssSelector("#langs > ul > li:nth-child(3) > a")).click();
              // 浏览器需要刷新,等待2秒钟
              Thread.sleep(2000);
              // 检查按钮上的字是不是变成了 English
              String expected_language = "English";
              String actual_language =
                      driver.findElement(By.cssSelector("#langs > button")).getText();
              Assert.assertEquals(actual_language, expected_language);
          }
          /**
           * 测试前置条件
           * 在所有的测试开始前 执行一次
           */
          @BeforeTest
          public void setUp() {
              this.baseDriver = new FirefoxDriver();
              this.baseUrl = "http://demo.ranzhi.org/";
          }
          /**
           * 测试清理操作
           * 在所有的测试结束后 执行一次
           */
          @AfterTest
          public void tearDown() {
              this.baseDriver.quit();
          }
      }

    • unittest

      接下来我们将会使用 Python 语言的unittest框架展开“检查”。unittest框架的原本的名字是PyUnit。是从JUnit 这样一个被广泛使用的 经典的Java应用开发的单元测试框架创造而来。类似的框架还有NUnit(.Net开发的单元测试框架)等。我们可以使用unittest框架为任意Python项目编写可理解的单元测试集合。现在这个unittest已经作为Python的标准库模块发布。我们安装完Python以后,便可以直接使用unittest。

      使用unittest需要以下简单的三步:

      • 引入unittest模组
      • 继承unittest.TestCase基类
      • 测试方法以test开头

      unittest 并未使用 Java 语言常见的注解方式,依旧停留在 比较早期的 Java 版本中依靠方法名称进行识别的方式。主要有以下两个固定名字的方法:

      • setUp():在每个测试方法运行前,执行。是测试前置条件。
      • tearDown():在每个测试方法运行后执行,是测试清理操作。

      具体的代码如下:

      class RanzhiMainTest(unittest.TestCase):
        """
        第一步:import unittest
        第二步:继承 unittest.TestCase 类
        第三步:测试的方法,以test_ 开头
        第四步:重写 setUp() 作为 测试前置条件,注意setUp的大小写,必须一致
        第五步:重写 tearDown() 作为 测试清理操作,注意 tearDown的大小写,必须一致
        """
        # 全局变量
        base_driver = None
        base_url = None
      
        def setUp(self):
            self.base_driver = webdriver.Firefox()
            self.base_url = "http://demo.ranzhi.org/"
      
        def tearDown(self):
            self.base_driver.quit()
      
        def test_01_change_language(self):
            driver = self.base_driver
            driver.get(self.base_url)
            sleep(2)
      
            driver.find_element_by_css_selector("#langs > button").click()
            sleep(1)
      
            driver.find_element_by_css_selector("#langs > ul > li:nth-child(3) > a").click()
            sleep(2)
      
            # 页面应该换成英语了
            actual_lang = driver.find_element_by_css_selector("#langs > button").text
            expected_lang = "English"
            # 与Java的TestNG 相反,先写期待值,再写实际值
            self.assertEqual(expected_lang, actual_lang)
      
        def test_02_log_in(self):
            driver = self.base_driver
            driver.get(self.base_url)
            sleep(2)
      
            driver.find_element_by_id("account").send_keys("admin")
            driver.find_element_by_id("password").send_keys("123456")
            driver.find_element_by_id("submit").click()
      
            sleep(3)
            actual_url = driver.current_url
            expected_url = self.base_url + "sys/index.html"
            self.assertEqual(expected_url, actual_url)

    2.2 使用 Page Object 设计模式

    Page Object设计模式是Selenium自动化测试项目的最佳设计模式之一,强调测试、逻辑、数据和驱动相互分离。

    Page Object模式是Selenium中的一种测试设计模式,主要是将每一个页面设计为一个Class,其中包含页面中需要测试的元素(按钮,输入框,标题等),这样在Selenium测试页面中可以通过调用页面类来获取页面元素,这样巧妙的避免了当页面元素id或者位置变化时,需要改测试页面代码的情况。当页面元素id变化时,只需要更改测试页Class中页面的属性即可。

    它的好处如下:

    • 集中管理元素对象,便于应对元素的变化
    • 集中管理一个page内的公共方法,便于测试用例的编写
    • 后期维护方便,不需要重复的复制和修改代码

    具体的做法如下:

    1. 创建一个页面的类
    2. 在类的构造方法中,传递 WebDriver 参数。
    3. 在测试用例的类中,实例化页面的类,并且传递在测试用例中已经实例化的WebDriver对象。
    4. 在页面的类中,编写该页面的所有操作的方法
    5. 在测试用例的类中,调用这些方法

    实现的示例

    • Page 基类

      • 设计了一个基本的Page类,以便所有的页面进行继承,该类标明了一个sub page类的基本功能和公共的功能。

      • 全局变量: this.baseDriver,让所有的子类都使用的。

      // 基类的变量,所有继承的类,都可以使用
      BoxDriver baseDriver;
      • 构造方法:

      • 默认的构造方法,无参数的构造方法

        public BasePage() {
        }
      • 传递 driver的构造方法

        public BasePage(BoxDriver driver) {
         this.baseDriver = driver;
        }
      • 私有的常量:存放元素的定位符

      private String START_BUTTON_SELECTOR = "s,#start > div";
      private final String EXIT_MENU_TEXT = "l,%s";
      • 成员方法:

      • 每个子类都需要的系统功能:

        • open
        public void open(String url) throws InterruptedException {
            this.baseDriver.navigate(url);
            Thread.sleep(2000);
        }
      • 所有子类(页面)都具有的业务功能

        • selectApp
        • logout
    • Sub Pages(s)子类

      • 具体的页面的类,定义了某个具体的页面的功能

      • 必须继承基类

      public class AdminPage extends BasePage {
      }
      • 创建构造方法,带driver 参数
      public AdminPage(BoxDriver driver) {
          super(driver);
      }
      • 特定页面的业务

      • 使用基类的 this.baseDriver 成员变量

    • Tests 类

      • 这部分描述的是具体的测试用例。

      • 声明全局变量

      private BoxDriver baseDriver = null;
      private String baseUrl = null;
      private LoginPage loginPage = null;
      private AdminPage adminPage = null;
      • 调用各种页面(pages)

        1. 实例化Page
        this.loginPage = new LoginPage(this.baseDriver);
        this.adminPage = new AdminPage(this.baseDriver);
        1. 使用page的对象,调用成员方法
        loginPage.open(this.baseUrl);    
        loginPage.changeLanguage(lang);
        loginPage.login("admin", "123456", true);
        loginPage.selectApp(AppType.Admin);
        adminPage.clickAddMemberButton();
        adminPage.addMemberData(member);

    2.3 使用数据驱动

    主要的数据驱动方式有两种:

    • 通过 文本文件或者 Excel 文件存储数据,并通过程序读取数据,遍历所有的行
    • 通过数据库存储数据,并通过程序和 SQL 脚本读取数据,遍历所有的行

    通过 CSV 文件 或者 MySQL 数据库,是主流的数据驱动方式。当然数据驱动也可以结合单元测试框架的参数化测试进行编写(此部分本文不做具体描述)。

    无论使用了 哪一种(CSV 或者 MySQL),读取数据后都要进行遍历操作。

    • Java 代码

      // 布尔型 true false
      boolean isFirstLine = true;
      // 循环每一个行,接下来根据每一行的值(数据),进行测试
      for (CSVRecord row : csvData) {
      if (isFirstLine) {
        isFirstLine = false;
        continue;
        // continue的作用
        // 当前循环到此为止,直接进入下一条循环
      }
      Member member = new Member();
      member.setAccount(row.get(0));
      member.setRealName(row.get(1));
      if (Objects.equals(row.get(2), "f")) {
        member.setGender(Member.Gender.Female);
      } else {
        member.setGender(Member.Gender.Male);
      }

      member.setDept(Integer.parseInt(row.get(3)));
      member.setRole(Integer.parseInt(row.get(4)));
      member.setPassword(row.get(5));
      member.setEmail(row.get(6));
      // TODO: 进行测试

      }
      “`

    • Python 代码

      is_header = True
      for row in csv_data:
        if is_header:
            is_header = False
            continue
        # dict 类型的数据
        member_data = {
            "account": row[0],
            "real_name": row[1],
            "gender": row[2],
            "dept": row[3],
            "role": row[4],
            "password": row[5],
            "email": row[6]
        }
        # TODO: 进行测试
      

    2.4 封装 Selenium WebDriver

    封装是一个面向对象编程的概念,是面向对象编程的核心属性,通过将代码内部实现进行密封和包装,从而简化编程。对Selenium进行封装的好处主要有如下三个方面:

    • 使用成本低
      1. 不需要要求所有的测试工程师会熟练使用Selenium,而只需要会使用封装以后的代码
      2. 不需要对所有的测试工程师进行完整培训。也避免工作交接的成本。
      3. 测试人员使用统一的代码库
    • 维护成本低
      1. 通过封装,在代码发生大范围变化和迁移的时候,不需要维护所有代码,只需要变更封装的部分即可
      2. 维护代码不需要有大量的工程师,只需要有核心的工程师进行封装的维护即可
    • 代码安全性
      1. 对作为第三方的Selenium进行封装,是代码安全的基础。
      2. 对于任何的代码的安全隐患,必须由封装来解决,使得风险可控。
      3. 使用者并不知道封装内部的代码结构。

    封装的具体示例:

    • 找到一个指定输入框(selector),并且输入指定的字符(text)

      type(selector, text)

      不用在业务逻辑中,使用多次的 findElement(By.id(...))

      public void type(String selector, String text) {
      WebElement we = this.locateElement(selector);
      we.clear();
      we.sendKeys(text);
      }
    • 找到一个可以点击的元素(selector),并且点击(click)

      click(selector)

      public void click(String selector) {
      this.locateElement(selector).click();
      }
    • 找到一个指定的frame,并且切换进去

      switchToFrame(selector)

      public void switchToFrame(String selector) {
      WebElement we = this.locateElement(selector);
      this.baseDriver.switchTo().frame(we);
      }
    • 找到一个指定的select,并且通过index进行选择

      selectByIndex(selector, index)

      public void selectByIndex(String selector, int index) {
      WebElement we = this.locateElement(selector);
      Select s = new Select(we);
      s.selectByIndex(index);
      }

    以上的代码是封装了locateElement()的几种方法,在具体使用封装过的代码的时候,只需要简单的调用即可。接下来的重点,是介绍 locateElement(selector)的封装方式。

    • 查找元素:findElement(By...)
    • 支持各种的查找:8种方式都需要支持,必须通过 selector 显示出分类
      • selector中需要包含一个特殊符号
      • 实例化 封装好的类的时候,需要约定好是什么特殊符号
        1. 强制性用硬编码 hard code来实例化,例如 , 或者 ? 或者 其他非常用字符 =>
        2. 或者,构造方法中,传递 this.byChar
    • 要把查找到元素的返回给调用的地方:必须要有返回值,类型是 WebElement
    private WebElement locateElement(String selector) {
      WebElement we;
      // 如果定位符中 有 分隔符,那么就从分隔符处分成两段
      // 第一段是By
      // 第二段是真正的定位符
      // 如果没有分隔符,就默认用 id 定位
      if (!selector.contains(this.byChar)) {
        // 用 id 定位
        we = this.baseDriver.findElement(By.id(selector));
      } else {
        // 用 分隔符 分成两个部分
        String by = selector.split(this.byChar)[0];
        String value = selector.split(this.byChar)[1];
        we = findElementByChar(by, value);
      }
      return we;
    }
    • 接下来的重点,是实现 findElementByChar(by, value)
    private WebElement findElementByChar(String by, String value) {
      WebElement we = null;
      switch (by.toLowerCase()) {
        case "id":
        case "i":
          we = this.baseDriver.findElement(By.id(value));
          break;
        case "css_selector":
        case "css":
        case "cssselector":
        case "s":
          we = this.baseDriver.findElement(By.cssSelector(value));
          break;
        case "xpath":
        case "x":
          we = this.baseDriver.findElement(By.xpath(value));
          break;
        case "link_text":
        case "link":
        case "text":
        case "linktext":
        case "l":
          we = this.baseDriver.findElement(By.linkText(value));
          break;
          //TODO: other by type
      }
      return we;
    }

    使用上面的封装类,就需要指定特定的 selector

    类型示例(分隔符以逗号,为例)描述
    id“account” 或者 “i,account” 或者 “id,account”分隔符左右两侧不可以空格
    xpath“x,//*[@id=”s-menu-dashboard”]/button/i”
    css selector“s,#s-menu-dashboard > button > i”
    link text“l,退出”
    partial link text“p,退”
    name“n,name1”
    tag name“t,input”
    class name“c,dock-bottom

    调用的具体示例

    void logIn(String account, String password) throws InterruptedException {
      BoxDriver driver = this.baseDriver;
      driver.type("account", account);
      driver.type("password", password);
      driver.click("submit");
      // 点击登录按钮后,需要等待浏览器刷新
      Thread.sleep(2000);
    }

    至此,自动化测试的方案如下图所示:

    自动化测试模型.png

    1. 封装 Selenium 为 BoxDriver
    2. 在 测试用例中,实例化 BoxDriver,产生 bd 对象
    3. 使用 bd 对象,构造 业务模块的实例化对象,产生 common
    4. 使用 common 在测试用例中,构建测试步骤
    5. 使用数据驱动的外部数据,通过读取,进行测试
    6. 执行整个用例

    2.5 使用 Git 进行源代码管理

    Git 是目前主流的源代码管理工具,本文推荐的两个 IDE 工具: JetBrains IDEA 和 JetBrains Pycharm 都是默认支持 Git 的。只需要按照以下步骤进行配置,便可以通过 IDE 工具对代码进行提交,这样可以防止代码丢失,以及方便的查询代码的修改历史,同时很方便团队的编码。

    使用编程工具提交代码(用IDEA 或者 PyCharm)

    1. 在本地的Git项目文件夹中创建项目
      • 比如:git\selenium_pro
      • 用IDEA 创建 Maven项目
        • 注意 project location务必在 git\selenium_pro
        • 比如 项目名字 HelloSelenium
        • 项目路径:git\selenium_pro\HelloSelenium
    2. 编写 代码
    3. 选择 IDEA 的 VCS | Enable Version Control Integration
    4. 弹出的窗口选择 Git
      • 所有的代码文件名字变成红色
    5. 右键 左侧的项目名字 HelloSelenium
      • 选择 Git | Add
      • 所有的代码文件名字变成绿色
    6. 右键 左侧的项目名字 HelloSelenium
      • 选择 Git | Commit Directory
      • 左侧填写 说明
      • 右侧勾选 Reformat Code
      • 选择右下角 Commit And Push
      • “XX文件已经committed”以后,点击 Push
      • 输入用户名 + 密码,勾选 remember password
      • push successful

    3. 架构的构建

    将第二部分的自动化测试方案付诸实践,再对自动化测试的结果生成测试报告,便基本上实现了自动化架构的构建。比较重要的地方是第三方工具 Selenium WebDriver 的封装工作。事实上,如果封装了别的工具,便可以实现其他方面的自动化测试。

    3.1 代码的构建

    在第二部分的基础上,我们添加上去测试组织和测试报告的功能,并且将不同作用的代码分开放入不同的文件夹中,实现代码的构建。

    • 测试用例的组织和执行

      • 测试集合 test suite
      • 测试用例的集合
        • 多个测试用例的类
        • 测试用例类的方法
      • 测试运行 运行 test suite

      具体的方法

      • TestNG

      在项目中,创建 testng.xml 文件如下

      <?xml version="1.0" encoding="UTF-8"?>
      <!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
      <suite name="Default Suite">
          <test name="SolutionSelenium">
              <classes>
                  <class name="cases.LoginTests">
                      <methods>
                          <!-- 添加指定的测试 -->
                          <include name="testLoginByCsv"/>
                          <include name="testLoginByCsv2"/>
                          <include name="testLoginByCsv3"/>
                      </methods>
                  </class> <!-- cases.LoginTests -->
                  <class name="cases.AdminTests">
                      <methods>
                          <!-- 去除指定的测试 -->
                          <exclude name="testAddMember"/>
                      </methods>
                  </class>
              </classes>
          </test> <!-- SolutionSelenium -->
      </suite> <!-- Default Suite -->
      • 指定测试的类
      • 指定测试的类中的方法
        • include: 一个个方法包含进来
        • exclude: 去除指定的方法

      然后,编写测试入口的脚本:Main.java

      public class Main {
          public static void main(String[] args) {
              TestNG test = new TestNG();
              List<String> suites = new ArrayList<>();
              suites.add("testng.xml");
              test.setTestSuites(suites);
              test.run();
          }
      }

    • 测试报告的生成

      • TestNG

      测试报告

      • TestNG 自带的测试报告 xml / html

      • ReportNG 测试报告的插件,停止开发和支持。

        Report detail page.

      • ExtentReport 测试报告

        • TestNG有默认的测试报告生成器 Listener
        • 使用 ExtentReport 重写一个 Listener
        • 让 TestNG 使用我们写好的 Listener 生成报告
      • 步骤

        • 引入 ExtentReport 到 pom.xml
        <dependency>
          <groupId>com.relevantcodes</groupId>
          <artifactId>extentreports</artifactId>
          <version>2.41.2</version>
        </dependency>
        • 目前 ExtentReport 有两个版本:2 和 3
          • 2 全部开源的
          • 3 有付费版和开源版
        • 官方网址:http://extentreports.com/community/

        • 编写 Listener : ExtentReporterNgListener

        @Override
        public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String outputDirectory) {
          Date date = new Date();
          SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd_HHmmss");
          String time = formatter.format(date);
        
          String reportName = String.format("ExtentReportTestNG_%s.html", time);
          // 创建报告
          // NetworkMode.OFFLINE 支持断网查看报告
          this.extent = new ExtentReports(
            outputDirectory + File.separator + reportName,
            true, NetworkMode.OFFLINE);
        
          for (ISuite suite : suites) {
            Map<String, ISuiteResult> result = suite.getResults();
        
            for (ISuiteResult r : result.values()) {
              ITestContext context = r.getTestContext();
              // 创建测试节点
              buildTestNodes(context.getPassedTests(), LogStatus.PASS);
              buildTestNodes(context.getFailedTests(), LogStatus.FAIL);
              buildTestNodes(context.getSkippedTests(), LogStatus.SKIP);
            }
          }
          extent.flush();
          extent.close();
        }
        • 修改 testng.xml

        <suite /> 中添加 <listener/>

        <listeners>
          <listener class-name="runner.ExtentReporterNgListener"/>
        </listeners>
        • 正常运行测试
    • unittest 的操作

      • 添加 test suite
      suite = unittest.TestSuite()
      suite.addTest(LoginTests("test_login_by_csv"))
      suite.addTest(LoginTests("test_login_by_csv2"))
      suite.addTest(AdminTests("test_add_member_by_csv"))
      • 这里可以配置测试,到外部文件,数据库中等。

        测试类,测试方法
        LoginTests,test_login_by_csv
        LoginTests,test_login_by_csv2
        AdminTests,test_add_member_by_csv

      • 实例化 test runner

      
      # 测试报告的文件
      
      test_time = time.strftime("%Y%m%d_%H%M%S", time.localtime())
      report_file = open("reports\\ranzhi_automate_report_%s.html" % test_time,
                         mode="wb")
      runner = HtmlTestRunner(stream=report_file,
                              verbosity=2,
                              title="然之系统自动化测试报告",
                              description="具体测试报告内容如下: ")

      HtmlTestRunner : 第三方测试报告运行器

      • 用 test runner 去执行测试,产生报告。
      runner.run(suite)

    3.2 使用持续集成

    持续集成,Continuous integration ,简称CI。随着软件开发复杂度的不断提高,团队开发成员间如何更好地协同工作以确保软件开发的质量已经慢慢成为开发过程中不可回避的问题。尤其是近些年来,敏捷(Agile) 在软件工程领域越来越红火,如何能再不断变化的需求中快速适应和保证软件的质量也显得尤其的重要。

    持续集成正是针对这一类问题的一种软件开发实践。首先我们看一下,敏捷教父 Martin Fowler 对持续集成的定义:

    Martin Fowler:Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly.

    具体定义:持续集成式一种软件开发实践。它倡导团队的成员必须经常的集成他们的工作,通常至少每天一次甚至更多次集成。每次集成都需要通过自动化的构建(包括编译代码、构建应用、部署程序以及自动化测试)来验证,从而尽早尽快的发现集成中的错误。大量的团队利用这样的方式来更快的开发内聚的软件。大大减少此过程中的集成问题。

    持续集成强调开发人员提交了新代码之后,立刻进行构建、(单元、自动化)测试。根据测试结果,我们可以确定新代码和原有代码能否正确地集成在一起。

    首先,解释下集成。我们所有项目的代码都是托管在SVN服务器上。每个项目都要有若干个单元测试,并有一个所谓集成测试。所谓集成测试就是把所有的单元测试跑一遍以及其它一些能自动完成的测试。只有在本地电脑上通过了集成测试的代码才能上传到SVN服务器上,保证上传的代码没有问题。所以,集成指集成测试。

    再说持续。不言而喻,就是指长期的对项目代码进行集成测试。既然是长期,那肯定是自动执行的,否则,人工执行则没有保证,而且耗人力。对此,我们有一台服务器,它会定期的从SVN中检出代码,并编译,然后跑集成测试。每次集成测试结果都会记录在案。完成这方面工作的就是下面要介绍的Jenkins软件。当然,它的功能远不止这些。在我们的项目中,执行这个工作的周期是1天。也就是,服务器每1天都会准时地对SVN服务器上的最新代码自动进行一次集成测试。

    CI_flow.png

    通过持续基础,可以将自动化测试良好的应用起来,只要是代码发生了变动,或者是进行代码的构建,那么在构建后都可以通过持续基础,自动的执行测试脚本,验证改进的功能。

    当前主要的持续基础工具有:

    • Jenkins
    • TeamCity

    通过持续集成,可以进一步完善自动化测试的架构,使得自动化测试真正的帮助项目,保证测试质量。

    3.3 参考代码

    本文的示例代码,放到了Github上面,以下附上Github的地址。为了简化操作,本代码使用了 Selenium 2 的环境,搭配 46.0(含)以下的火狐浏览器,以便各位参考。

    代码将会持续更新。

    代码地址:https://github.com/lintyleo/seleniumpro

    再次感谢各位花时间阅读本文,由于时间紧迫,以及才疏学浅,文中难免出现各种疏漏,还请各位多多指教。不当之处,还欢迎各位指出,在此谢过。

    展开全文
  • Selenium自动化测试,接口自动化测试开发,性能测试从入门到精通Selenium接口性能自动化测试基础部分:分层自动化思想Slenium介绍Selenium1.0/2.0/3.0Slenium RC, WebDriver, IDE, GridPython+selenium环境版本选择...

    Selenium自动化测试,接口自动化测试开发,性能测试从入门到精通
    Selenium接口性能自动化测试
    基础部分:
    分层自动化思想
    Slenium介绍
    Selenium1.0/2.0/3.0
    Slenium RC, WebDriver, IDE, Grid
    Python+selenium环境
    版本选择
    安装selenium
    浏览器驱动设置
    Python基础
    输入、输出、数组、字典,分支、循环
    引包机制
    函数、类、方法
    异常处理
    WebDriver API
    元素定位
    20个例子演示WebDriver各种场景的操作。
    自动化测试模型
    线性测试、模块化、数据驱动、关键字驱动
    模块化实例
    数据驱实例
    txt、csv、xml文件的操作
    selenium IDE
    脚本的录制与导出
    unittest单元测试框架
    编写单元测试
    断言
    fixture
    测试套件
    测试运行
    编写selenium自动化测试
    集成HTMLTestRunner
    集成自动发邮件
    Selenium Grid2
    selenium源码分析
    多浏览器运行测试
    多平台多浏览器运行测试
    各种驱动支持
    docker-selenium
    docker 安装
    docker相关概念
    docker-selenium镜像安装与应用
    Page Object设计模式
    基于selenium的二次封装
    selenium 源码分析
    pytest单元测试框架
    减少用例编写
    减少测试运行时间
    用例失败自动截图
    实战
    基本pytest单元测试框架构建自动化测试项目
    appium自动化测试

    appium基础
    appium介绍,与selenium的关系
    appium工作原理
    android SDK
    appium-python-client
    appium应用
    app元素定位
    appium API
    结合 单元测试框架编写自动化测试
    实战部分:

    安装php + msyql + apache
    如何编写自动化测试用例
    自动化测试的流程是什么?
    分层测试思想与自动化的ui测试
    实战:几乎所有系统都有的登录功能与相关断言
    作业:数据驱动的用例设计及精讲
    实战:创建一篇博客文章与富文本编辑器的操作
    作业:各种表单实战及精讲
    实战:删除文章与页面事件的模拟
    作业:实战iframe与动态等待及精讲
    实战:使用po重构测试用例与框架的雏形
    实战:框架中自动包含动态等待及出错截图
    作业:批量执行用例与所有用例的po重构
    CI持续集成精讲,测试框架上CI进行持续测试
    扩展内容:html+css选择器+javascript

    =======================
    接口自动化测试开发
    课程特色:
    测试开发/高级测试工程必备
    基于Django框架全面介绍Web开技术
    实战接口自动化测试框架开发
    年接口自动化实战经验分享

    Web开基础:

    Python基础
    安装、IDE选择与常见问题
    Django基础
    hello Django
    django工作原理
    开发发布会签到系统
    登录
    发布会管理(查询)
    嘉宾管理(查询,翻页)
    签到功能
    Django 单元测试
    系统接口开发
    接口测试开发:

    接口测试基础
    接口测试工具介绍
    postman
    JMeter
    Robot Framework
    接口自动化测试框架
    unittest + pymysql + request + HTMLTestRunner
    接口安全测试
    认证
    签名
    加密
    web Service 技术
    SOAP接口开发与测试
    REST技术
    Django-REST-Framework开发接口平台
    soapUI工具介绍
    实例分析
    某接口平台,代码实现分析
    如何设计接口用例
    测试平台接口代码分析
    实战部分:

    第1章: 部署我们的测试环境

    部署化测试环境
    smile task api简介
    测试用例的3A原则
    练习
    第2章: Token Based Authentication and JWT]

    Token Based Authentication
    JWT简介
    练习
    第3章: 基于HTTP协议的mock server

    什么是mock server
    实战:使用flask实现mock server
    练习
    第4章: 扩展内容: swagger文档和jsonapi

    swagger
    jsonapi
    密码学
    第5章: 持续集成

    持续集成简介
    安装
    最简单的测试job
    添加HTML测试报告
    git支持及代码库监控
    实战:使用jenkins运行smile_task接口测试用例
    第六章:调用接口开发一些小程序

    豆瓣cli
    viewjs todo list
    第七章:接口测试面试题详解

    =======================
    性能测试从入门到精通
    课程目标:
    性能专项测试培训,通过压力测试工具(jmeter/locust)/siege等了解性能测试的基本原理及性能测试流程。 学会目前主流的性能测试类型:web性能测试及接口性能测试。

    学会使用主流性能测试工具:jmeter/locust/siege等
    学会使用linux及进行linux环境搭建和性能监控
    学会性能测试的流程和方法,能够自主进行性能测试
    学会性能测试的种种套路,比如测试场景分析,脚本编写,基准验证,测试报告及性能瓶颈的简单分析

    课程大纲
    性能测基础
    性能测试分类
    性能测试概念(并发用户、吞吐量、响应时间)
    当你拿到一个性能需求时,需要稿明白哪些问题?
    性能测试的职位理解,薪资分析,知识架构及学习方法
    性能测试的本质
    场景(客户端/服务器)
    表现(性能好的表现/性能不好的表现)
    度量(如何去度量性能)
    指标(客户端指标/服务器指标)
    从浏览器发出请求到页面被渲染,其间究竟发生了什么 震惊!浏览器发出请求后竟然经历了那么多见不得人的事情
    服务器是如何工作的
    客户端是如何工作的
    web服务器基本架构
    服务器(Apache、Nginx、tomcat)
    web服务(PHP、Java、Python)
    数据库(MySQL、PG)
    关于服务器并发
    为什么要并发
    benchamark(什么是benchmark?)
    如何产生并发(ab、jmeter、locust、LR、go)
    并发时服务器在什么(服务器、web服务、数据库)
    如何观察服务器状态(监控工具、服务器性能指标)
    Jmeter工具使用
    购买云服务器
    简单的linux命令
    搭建被测项目
    第一个Jmeter脚本
    如何查看jmeter文档快速获取帮助
    Jmeter的测试计划
    学会阅读简单的Jmeter测试报告
    Jmeter脚本的执行顺序
    Jmeter录制与回放
    测试场景
    配置HTTP代理
    开始录制
    查看结果
    Jmeter组件详解
    Test Plan
    WorkBench
    Thread Group
    Recoding Controller
    HTTP Request
    HTTP Header Manager
    为脚本增加新功能
    HTTP Request Defaults
    Random Variable
    Jmeter中变量使用详解
    请求与编码
    增加随机选取关键字功能
    使用javascript进行逻辑增强
    Timter
    Jmeter函数详解
    从CSV文件中读取测试数据
    CSV data set config
    总结
    Jmeter项目实战
    后台登陆
    多用户登陆
    创建及编辑文章
    删除文章
    浏览文章
    性能测试流程
    需求分析
    确定测试目标
    确定测试周期
    准备测试数据
    开发测试脚本
    验证脚本
    运行脚本
    测试报告
    使用Jmeter测试基于json的Restful接口
    了解被测项目
    搭建被测项目
    使用nodejs实现简单的接口(express、route、orm)
    实现接口脚本
    通过jwt鉴权(基于token的鉴权、基于cookie的鉴权)
    none gui模式产生负载
    生成html测试报告
    Jmeter集群模式——产生更大的负载
    配置集群
    产生负载
    聚合报告
    Jmeter二次开发
    产生负载
    Jmeter扩展
    报告分析及系统监控
    60秒定位linux系统问题(uptime、dmesg、vmstat、mpstat、pidstat、iostat、free、sar、top)
    监控工具
    监控指标
    报告分析
    后台系统调优
    业务调优
    代码调优
    sql调优
    专项调优
    前端性能调优
    减少请求数量
    减少请求大小
    善用缓存
    善用cdn
    ......
    实战

    第一章 Flask项目部署
    Flask项目
    安装flasky项目
    配置邮箱服务
    性能模式运行项目
    uWSGI
    1、uWSGI介绍
    2、安装uWSGI
    3、uWSGI运行Flask
    Nginx
    1、安装Nginx
    2、Nginx+uWSGI+Flask
    第二章 性能测试
    Locust性能测试工具
    安装Locust
    性能测试例子
    系统性能测试
    性能测试准备
    编写性能测试脚本
    执行性能测试
    接口性能测试
    编写接口性能测试脚本
    执行接口性能测试

    展开全文
  • 自动化测试的理论知识,遂拿过来学习学习。所以本文几乎没有实践内容,大多都是概念和工具的 mark,后续若有实践,我会来补充的。 一、软件测试 分类 1、根据项目流程阶段划分 需求分析 设计 编码 单元测试 集成...

    背景


    最近在弄 appium,然后顺便发现了 Selenium 框架和这本书,恰好这本书也介绍了一些软件测试&自动化测试的理论知识,遂拿过来学习学习。所以本文几乎没有实践内容,大多都是概念和工具的 mark,后续若有实践,我会来补充的。

    一、软件测试 分类


    1、根据项目流程阶段划分

    • 需求分析

    • 设计

    • 编码

    • 单元测试

    • 集成测试

    • 系统测试

    • 验收测试

    896608-20190915020107890-1434250996.png

    2、白盒测试、黑盒测试、灰盒测试

    白盒测试的意义:有时候输出是正确的,但内部其实已经错误了,这种情况非常多。

    灰盒测试的意义:如果每次都通过白盒测试来操作,效率会很低,黑盒又太过笼统,因此折中的灰盒测试比较适合。

    3、功能测试与性能测试

    功能测试主要检査实际功能是否符合用户的需求。

    功能测试又可以细分为很多种:逻辑功能測试、界面测试、易用性测试、安装测试、兼容性测试等。


    性能测试主要有时间性能空间性能两种。

    时间性能:主要是指软件的一个具体的响应时间。

    空间性能:主要指软件运行时所消耗的系统资源。

    4、手工测试与自动化测试

    自动化测试不能完全地替代手工测试,自动化测试的目的仅仅在于让测试人员从烦琐重复的测试过程中解脱出来,把更多的时间和精力放到更有价值的测试中,例如探索性测试。而自动化测试更多的是用来进行冒烟测试和回归测试。

    自动化测试是本文要探讨的重点。

    5、冒烟测试、回归测试、随机测试、探索性测试和安全测试

    冒烟测试:引入到软件测试中,就是指测试小组在正式测试一个新版本之前,先投入较少的人力和时间验证一个软件的主要功能,如果主要功能都没有运行通过,则打回开发组重新开发。这样做的好处是可以节省时间和人力投入到不可测的项目中。

    回归测试:回归测试是指修改了旧代码后,重新进行测试以确认修改后没有引入新的错误或导致其他代码产生错误。

    随机测试

    探索性测试

    安全测试

    6、正向测试与逆向测试

    正向测试用例 (Positive Test Case) 和反向测试用例 (Negtive test Case) 是对测试用例的一种分类。

    例如:一个输入只能接受输入数字0-9,那么正向用例可以为:0,1,2,3,4,5,6,7,8,9,反向用例可以为:其它值。

    反向测试用例通常指,系统不支持的输入或则状态,这类用例可以检查系统的容错能力、健壮性和可靠性。

    二、何为自动化测试


    自动化测试的概念有广义与狭义之分:广义上来讲,所有借助工具来辅助进行软件测试的方式都可以称为自动化测试:狭义上来讲,主要指基于 UI 层的功能自动化测试

    注意:如果没有特别说明,则本文所说的“自动化测试”均指“基于 UI 的功能自动化测试”。

    三、自动化测试 与 分层模型


    1、测试金字塔

    不同测试阶段所投入的自动化测试的比例:Unit > Service > UI。

    896608-20190915020117978-1728592068.png

    2、Unit 层

    单元测试:单元就是人为规定的最小的被测功能模块。规范的进行单元测试需要借助单元测试框架,如 Java 语言的 Junit、TESTNG, C# 语言的 Nunit,以及 Python 语言的 unittest、pytest 等,目前几乎所有的主流语言都有其相应的单元测试框架。

    Code Review:与 Code Review 相关的插件和工具有很多,例如 Java 语言中基于 Eclipse 的 Review Clipse 和 Jupiter、主要针对 Python 语言的 Review Board 等。

    现在因为 github/gitlab 的流行, 以前的工具用的很少了。不排除大厂用一些更专业的工具。

    拓展:Code Review

    目的:

    1、改善代码质量

    一些很基础的,比如缩进空格什么的,就交给 eslint 什么的去解决吧。

    2、保证团队代码规范

    3、提高代码性能

    4、预防 bug

    5、加深技术团队成员沟通,营造技术氛围

    6、老带新互助成长

    实践建议:

    1、所有代码都必须经过 Review 才能 merge。

    2、批评的时候最好同时给解决方案

    3、每次 review 至少给一条正面评价,提高对方信心

    4、不要在 review 中讨论需求

    5、不要在 review 中讨论太多的架构或者设计模式,这个应该是在前期设计时解决的事

    普及情况:

    Code Review 做得好的普遍是一些比较偏技术的团队,而偏业务的技术团队比较少。

    我们公司也很少做其实。

    3、Service 层

    接口测试:也有相应的类库或工具,例如测试 HTTP 的有 Httpunit、Postman 等。

    4、UI 层

    UI 自动化测试:目前主流的测试工具有 UFT、Watir、Robot Framework、Selenium 等。

    JS 自动化测试:Qunit 就是针对 Javascript 的一个强大的单元测试框架,由jQuery团队的成员所开发,并且用在jQuery,jQuery UI,jQuery Mobile等项目。

    其实这个也是单元测试,但是因为是前端,所以归到了 UI 这边。

    四、什么样的项目适合自动化测试


    (1)软件需求变动不频繁

    或者一种折中的做法是先对系统中相对稳定的模块与功能进行自动化测试,而变动较大的部分用手工进行测试。

    (2)项目周期较长

    (3)自动化测试脚本可重复使用

    (4)等等

    五、自动化测试模型


    1、线性测试

    最原始的方法,测试用例之间可能会存在重复的操作,会导致开发成本和维护成本都很高。

    2、模块化驱动测试

    很好地解决了脚本的重复问题。

    3、数据驱动測试

    因为输入数据的不同从而引起输出结果的不同。实现了数据与脚本的分离。

    4、关键字驱动测试

    理解了数据驱动后,无非是把“数据”换成“关键字”,通过关键字的改变引起测试结果的改变

    好处:

    目前市面上典型关键字驱动工具以 QTP(目前已更名为 UFT- Unified Functional Testing)、Robot Framework (RIDE)工具为主。这类工具封装了底层的代码,提供给用户独立的图形界面,以“填表格”的形式免除测试人员对写代码的恐惧,从而降低脚本的编写难度,我们只需使用工具所提供的关键字以“过程式”的方式来编写用例即可。

    坏处:

    关键字驱动也可以像写代码一样写用例,在编程的世界中,没有什么不能做:不过这样的用例同样需要较高的学习成本,与学习一门编程语言几乎相当。这样的框架越到后期越难维护,可靠性也会变差,关键字的用途与经验被局限在自己的框架内,你所学到的知识也很难重用到其他地方。所以,从测试人员的经验与技术积累价值来讲,笔者更倾向于直接通过编程的方式开发自动化脚本。

    六、自动化测试工具 - selenium 2(UI层)


    本章实操部分省略,后续若有实践,会适当补充。

    有人说我们公司的软件是用某语言开发的,所以自动化测试也要选某语言:其实软件开发语言和软件自动化测试语言没有必然联系。也就是说,基于 Python (+ Selenium)编写的自动化测试脚本既可以测试基于 Java 开发的 Web 项目,也可以测试基于 PHP 开发的 Web 项目。所以,在选择 Selenium 自动化测试语言时不需要考虑与开发语言的一致性。

    1、什么是 selenium 2

    selenium 2 是 web 浏览器自动化测试框架。

    下文的 selenium 默认都指 selenium 2。

    虽然 selenium 支持 Android 自动化测试,但更推荐 Appium, Appium 是 selenium 的延伸,基本上可以视为 “Selenium for Apps”,因为它也是基于 Selenium 的 Webdriver 技术开发的。

    2、selenium 历史

    selenium (selenium 1) 和 webdriver 原来是两个不同的开源项目,但在 selenium 2 的时候,将selenium 与 webdriver 合并了,即:

    selenium 2 = webdriver + selenium 1

    所以 selenium 2 可以等价为 webdriver ,对于 Selenium 2 的学习,其实是对 WebDriver API 的学习。

    3、selenium 的支持模式

    selenium 支持 HtmlUnitPhantomJS 两个模式。

    Phantom JS 是一个拥有 Javascript API 的无界面 Webkit 内核,与 Htmlunit 类似,但比它更高级一些。

    通过 HtmlUnit 或 Phantom JS 进行的自动化测试运行不会真正打开一个浏览器,在我们看来,可见的东西才会觉得是真实的,需要的时候,可以调用截图的 api。

    4、安装 selenium

    pip3 install selenium

    5、常用功能

    • 控制浏览器:如调整窗口大小

    • 找元素(定位)

    • 操作元素

    • 鼠标事件

    • 键盘事件

    • 设置元素等待

    • 多 frame、iframe 切换 / 多窗口切换

      调用switch_to.frame()switch_to.window()

    • 处理警告框
      如接受警告框:driver.switch_to_alert().accept()

    • 上传/下载文件
      更复杂的上传/下载需要编写 Autoit 脚本

    • 操作 Cookie

    • 调用 JS
      调用 execute_script()

    6、Selenium IDE

    通过浏览器插件的形式提供。

    896608-20190915020228353-1145951885.png

    功能点备注:

    1、断言和验证的区别:与断言相比,当执行验证命令失败后不会终止测试。

    2、pause 和 waitfor 的区别: pause 来设置固定时间的体眠,而 waitfor 则用于在一定时间内等待某一元素显示。

    3、支持将录制内容导出为代码,支持类型如下:

    Ruby/Rspec/Webdriver

    Ruby/Rspec/Remote Control

    Ruby/Test: Unit/ Webdriver

    Ruby/Test: Unit/Remote Control

    Python/unittest/Webdriver

    Python/unittest/Remote Control

    Java/Junit4/Webdriver

    Java/Junit4/Webdriver Backed

    Java/Junit4/Remote Control

    Java/Junit3/Remote Control

    Java/TESTNG/Remote Control

    C#/Nunit/Webdriver

    C#/Nunit/Remote Control

    7、Selenium Grid 2

    (1)介绍

    利用 Selenium Grid 2 可以在不同的主机上建立主节点(hub)和分支节点(node),可以使主节点上的测试用例在不同的分支节点上运行。对不同的节点来说,可以搭建不同的测试环境(操作系统、浏览器),从而使一份测试用例得到不同环境下的执行结果。

    (2)安装

    Selenium Grid 2 的时候,不再提供单独的包,其功能已经集成到 Selenium Server 中,所以,需要下载和运行 Selenium Server オ可以使用 Grid 2 的功能。

    下文中 Selenium Grid 2 都简称为 Selenium Grid。

    (3)缺点与改进

    Selenium Grid 只是提供多系统、多浏览器的执行环境,Selenium Grid 本身并不提供并行的执行测试用例。所以建议使用多线程技术结合 Selenium Grid 实现分布式并行地执行测试用例

    七、 自动化测试工具 - unittest(python单元测试框架)


    在 Python 语言下有诸多单元測试框架,如 doctest、unittest、pytest、nose 等,unittest 框架(原名 Pyunit 框架)为 Python 语言自带的单元测试框架,Python2.1 及其以后的版本已将 unittest 作为一个标准模块放入 Python 开发包中。

    1、概念

    单元测试本身就是通过一段代码去验证另一段代码。

    (1)Test Case

    一个 Testcase 的实例就是一个测试用例

    • 一个用例为一个完整的场景,从用户登录系统到最终退出并关闭浏览器。

    • 一个用例只验证一个功能点,不要试图在用户登录系统后把所有的功能都验证一遍。

    • 用例与用例之间尽量避免产生依赖

    • 一条用例完成测试之后需要对测试场景进行还原,以免影响其他用例的执行。

    (2)Test Suite

    一个功能的验证往往需要多个测试用例,可以把多个测试用例集合在一起来执行,这就产生了测试套件Testsuite 的概念。

    (3)Test Runner

    包含执行策略和执行结果。

    (4)Test Fixture

    对一个测试用例环境的搭建和销毁,就是一个 fixture。

    2、使用

    待写

    3、生成 HTML 测试报告

    HTMLTestRunner 是 unittest 的一个扩展,它生成易于使用的 HTML 测试报告。

    待写

    4、缺点

    跟上面说的 Selenium Gird 一样,unittest 单元测试框架本身并不支持多线程技术,它不能像 Java 的 TESTNG 框架一样通过简单的配置就可以使用多线程技术执行测试用例。

    八、自动化测试高级应用


    1、自动发邮件功能

    SMTP (Simple Mail Transfer Protocol)是简单邮件传输协议。

    Python 的 smtplib 模块提供了一种很方便的途径用来发送电子邮件。

    可用于如测试时结果的告知。

    2、Page Object 设计模式

    Page 对象(Page Object)的一个基本经验法则是:凡是人能做的事,page 对象通过软件客户端都能够做到。因此,它也应当提供一个易于编程的接口并隐藏窗口中底层的部件。所以访问一个文本框应该通过一个访问方法(accessor method)来实现字符串的获取与返回,复选框应当使用布尔值,按钮应当被表示为行为导向的方法名。page 对象应当将在 GUI 控件上所有查询和操作数据的行为封装为方法。一个好的经验法则是,即使改变具体的控件,paee 对象的接口也不应当发生变化。

    也可以建立一个 base 的 Page 对象,让别的 page 继承它。

    很像面向对象编程思想里的接口与实现。

    九、自动化测试项目实战


    待写

    转载于:https://www.cnblogs.com/xjnotxj/p/11520983.html

    展开全文
  • 本主要介绍以Java为基础,搭建Selenium自动化测试环境,并且实现代码编写的过程。1.Selenium介绍Selenium 1.0 包含 core、IDE、RC、grid 四部分,selenium 2.0 则是在两位大牛偶遇相互沟通决定把面向对象结构化...
  • selenium进行自动化测试

    千次阅读 2021-03-19 20:48:52
    根据网络资料,总结了以下一些常见的接口测试面试题: 为什么要做接口测试接口测试能发现哪些问题? 接口测试怎么测? 用什么工具测接口? WebService接口是如何测试的? 没有接口文档如何做接口测试? 在...
  • Selenium自动化测试

    2021-01-26 20:03:12
    一.自动化测试理念 ...Selenium是一个web自动化测试工具 它的主要优点: 免费,开源,轻巧 支持多语言:Java ,C#,python,ruby 支持多平台:Chrome,IE,Firefox,Safari,edge,Opera,不同操作系统 支持分布式 2.jme
  • 之前分享了python和requests搭配实现的接口自动化测试框架,今天,我再来整理分析下基于python和selenium的web UI自动化测试,希望能对大家有所帮助,也是自己整理知识学习的方法,跟大家一起努力,奋斗在自动化测试...
  • 性能测试,功能测试,自动化测试接口测试,移动端测试,手机测试,WEB测试,渗透测试,测试用例设计,黑盒测试,白盒测试,UFT高级测试,Android测试,Selenium3自动化测试,Python3 测试,Java接口测试项目实战...
  • SoapUI + Selenium Webdriver实现自动化测试
  • 接口自动化测试框架 一、接口测试工具 1. jmeter jmeter 是一个非常流行的性能测试工具,优点 开源、小巧、易于安装。 2. postman postman常用于开发中,可将请求的链接直接复制,然后构造自己所想要的入参进而...
  • 在学习完Selenium的大部分接口或者方法之后,你可能会去面试自动化测试,主要是Selenium自动化测试。下面这些问题总结,可能会对你有所帮助。 什么是SeleniumSelenium是一个开源的web自动化测试框架,...
  • Selenium 是web自动化测试工具集,包括IDE、Grid、RC(selenium 1.0)WebDriver(selenium 2.0)等。 Selenium IDE 是firefox浏览器的一个插件。提供简单的脚本录制、编辑与回放功能。 Selenium Grid 是用来对测试...
  • 自动化测试正席卷全球,Selenium 认证是业界最抢手的技能之一。 什么是 SeleniumSelenium 是一种开源工具,用于在 Web 浏览器上执行自动化测试(使用任何 Web 浏览器进行 Web 应用程序测试)。   等等,先别...
  • 它是一个FireFox 插件,实现浏览器的录制与回放功能,提供创建自动化测试的建议接口Selenium IDE 有一个记录功能,能记录人工的操作,并且能选择多种语言把它们导出到一个可重用的脚本中用于后续执行。如果没有...
  • UI Automatic Testing 1. 什么样的项目适合自动化测试...2. 常见的自动化测试工具简介3. Selenium介绍4. Selenium的工作原理 1. 什么样的项目适合自动化测试? 定义:把人为驱动的测试转化为机器执行的一种过...
  • 适合自动化测试的项目1、任务测试明确,不会频繁变动 2、每日构建后的测试验证 3、比较频繁的回归测试 4、软件系统界面稳定,变动少 5、需要在多平台上运行的相同测试案例、组合遍历型的测试、大量的重复任务 6...
  •  前面一直在讲接口自动化测试框架与案例分享,很少讲Selenium这个Web自动化测试神器。它主要用来做UI自动化测试,大家都知道UI自动化测试成本相当高,一般的Web自动化测试我是一直不建议做的。  虽然不推荐,但是...
  • 自动化测试的目的是为了提高测试的效率,减少人工的...python+selenium是web ui的自动化测试。一般自动化的测试在所有测试里面是排在最后的,最先的是接口的测试,其次是功能测试,最后是自动化测试。那么UI级的界...
  • 全栈工程师开发手册 (作者:栾鹏) python教程全解 ...Selenium IDE(如果用Firefox) FireBug、FirePath(如果用Firefox) chromedriver、IEDriverServer、phantomjs.exe IDE(Pycharm/Subl...
  • 自动化测试 1. 什么是自动化 2. Web自动化测试 3. 测试中自动化的应用 测试流程 selenium工具集
  • 文章目录selenium的下载地址在eclipse中导入selenium的jar一个简单的例子 selenium的下载地址 Selenium官网: https://docs.seleniumhq.org/download/ Selenium各版本下载: ...
  • 编写接口自动化测试用例的童鞋都清楚,解决接口自动化数据依赖问题是接口自动化测试用例中很重要的一部分,所以今天我给大家分享常见的三种解决接口自动化测试的数据依赖问题的方法 一:使用setUp解决数据依赖问题 ...
  • 忽然想谈谈自动化的学习路径,因为发现很多人总是急于求成,不懂该如何学习。 在学习或者工作中,难免会遇到很多...作为一个测试人员,做自动化一般是指接口自动化与UI自动化。(接口也是指对外的部分,通过各种协议,
  • selenium是一个web自动化测试工具,本身向python提供编程接口,至于搭建使用的话,只需要安装一下selenium模块,并配置一下浏览器驱动就行,下面我简单介绍一下实现过程,感兴趣的朋友可以尝试一下:1.首先,安装...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,969
精华内容 5,587
关键字:

selenium接口自动化测试