自动化测试框架 订阅
自动化测试框架,即是应用于自动化测试所用的框架。按照框架的定义,自动化测试框架要么是提供可重用的基础自动化测试模块,如:selenium [1]  、watir等,它们主要提供最基础的自动化测试功能,比如打开一个程序,模拟鼠标和键盘来点击或操作被测试对象,最后验证被测对象的属性以判断程序的正确性;要么是可以提供自动化测试执行和管理功能的架构模块,如:Phoenix Framework,robot [2]  ,STAF [3]  等,它们本身不提供基础的自动化测试支持,只是用于组织、管理和执行那些独立的自动化测试用例,测试完成后统计测试结果,通常这类框架一般都会集成一个基础自动化测试模块,如:robot框架就可以集成selenium [4]  框架,Phoenix Framework集成的也是selenium框架。 展开全文
自动化测试框架,即是应用于自动化测试所用的框架。按照框架的定义,自动化测试框架要么是提供可重用的基础自动化测试模块,如:selenium [1]  、watir等,它们主要提供最基础的自动化测试功能,比如打开一个程序,模拟鼠标和键盘来点击或操作被测试对象,最后验证被测对象的属性以判断程序的正确性;要么是可以提供自动化测试执行和管理功能的架构模块,如:Phoenix Framework,robot [2]  ,STAF [3]  等,它们本身不提供基础的自动化测试支持,只是用于组织、管理和执行那些独立的自动化测试用例,测试完成后统计测试结果,通常这类框架一般都会集成一个基础自动化测试模块,如:robot框架就可以集成selenium [4]  框架,Phoenix Framework集成的也是selenium框架。
信息
定义来分类
基础功能测试框架、管理执行框架
部署方式来分
单机自动化测试框架
中文名
自动化测试框架
简    介
应用于自动化测试所用的框架
自动化测试框架涵义
什么是自动化测试框架在了解什么是自动化测试框架之前,先了解一下什么叫框架?框架是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用方面,而后者是从目的方面给出的定义。 从框架的定义可以了解,框架可以是被重用的基础平台;框架也可以是组织架构类的东西。其实后者更为贴切,因为框和架本来就是组织和归类所用的。所以自动化测试框架的定义为:由一个或多个自动化测试基础模块、自动化测试管理模块、自动化测试统计模块等组成的工具集合。按框架的定义来分,自动化测试框架可以分为:基础功能测试框架、管理执行框架;按不同的测试类型来分,可以分为:功能自动化测试框架、性能自动化测试框架;按测试阶段来分,可以分为:单元自动化测试框架、接口自动化测试框架、系统自动化测试框架;按组成结构来分,可以分为:单一自动化测试框架、综合自动化测试框架;按部署方式来分,可以分为:单机自动化测试框架、分布式自动化测试框架。
收起全文
精华内容
下载资源
问答
  • 基于Springboot+Mybatis打造接口自动化测试框架-全网最新最全最具技术含量的接口自动化测试及框架编写
  • WebUI自动化测试框架

    2019-08-07 23:57:21
    本项目是一个基于Selenium的Web自动测试框架,通过该框架可以简化测试人员的学习难度,只要编写少量的Java代码即可,大多数的工作都是编写页面元素的描述文件以及对应的数据源。
  • Jmeter接口自动化测试框架是我自己写的文档,很适合想入门接口自动化的人,该文档很详细,没有一点跳步,值得想入门的人看
  • 基于python的selenium UI自动化测试框架,采用Page Object设计模式进行二次开发,通过对页面对象和测试代码进行分离,并封装了日志输出,浏览器引擎选择,二次封装常用方法
  • 该文档是基于python的自动化测试框架的搭建,详细介绍了框架的具体信息以及各个模块的含义,对于最终搭建该框架起到重要作用。
  • 接口自动化测试框架

    2018-04-02 22:38:53
    搭建接口自动化测试框架 搭建接口自动化测试框架 搭建接口自动化测试框架 搭建接口自动化测试框架
  • pytest 自动化测试框架
  • github地址: https://github.com/wuranxu/webTest 基于Python的webUI自动化测试框架,支持多平台~带有自动下载chrome驱动功能
  • java自动化测试框架

    2018-09-20 21:18:27
    java自动化测试框架
  • Pytest是Python最强大的自大化测试框架,本资料内容详细介绍pytest使用方法,基于Python3.6,python零基础勿扰,selenium零基础勿扰
  • requests 实现的 api 自动化测试框架,只需要配置api对应的url ,request_method,既可以实现api的 自动化测试,并输出详细的测试报告
  • 基于Appium与python构建App自动化测试框架,主要讲述如何搭建自动化测试
  • java+selenium+maven+testng自动化测试框架实例(实际项目)
  • 基于python的接口自动化测试框架讲解用PPT,为了能让学员更好的理解接口自动化测试框架的PPT。
  • WebWEB自己动手写Web自动化测试框架6-自动化测试框架的规划软件测试从今天开始,我们正式进入自动化测试框架的编写中。首先我们先进行需求分析:我们到底要什么样的自动化测试框架?正如第一篇《自己动手写Web自动化...
  • rest服务自动化测试框架,使用xls文件写测试用例。
  • 【自动化测试】自动化测试框架与工具

    千次阅读 多人点赞 2021-05-06 21:01:01
    文章目录1)什么是自动化测试框架?1.1 什么是框架?1.2 什么是自动化测试框架?1.2.1 优点:1.2.2 框架的基本组件1、需要配置文件管理:2、业务逻辑代码和测试脚本分离3、报告和日志文件输出4、自定义的库的封装5、...



    1)什么是自动化测试框架?

    1.1 什么是框架?

    框架是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法。它规定了应用的体系结构,阐明了整个设计、协作构件之间的依赖关系、责任分配和控制流程,表现为一组抽象类以及其实例之间协作的方法。

    框架一般是成熟、稳健的,它可以处理系统很多细节问题,比如,事物处理,安全性,数据流控制等问题。还有框架一般都经过很多人使用,所以结构很好,所以扩展性也很好,而且它是不断升级的,可以直接享受别人升级代码带来的好处。

    1.2 什么是自动化测试框架?

    自动化测试框架是为自动化测试用例或者脚本提供执行环境而搭建的基础设施。自动化测试框架有助于有效地开发、执行和报告自动化测试用例。

    1.2.1 优点:

    • 代码复用
    • 提高测试效率
    • 更高的测试覆盖率
    • 维护成本低
    • 更早发现和记录bug

    在这里插入图片描述

    1.2.2 框架的基本组件

    1、需要配置文件管理:

    一般需要一个配置文件去控制一些环境信息、开关。配置文件可以是txt/xml/yaml/properties/ini,一般.properties使用较多在JAVA里,Python的话通常会选择ini文件。

    2、业务逻辑代码和测试脚本分离

    如果代码和脚本在一个类文件,那么就根本没有用到代码重构,复用。代码和用例文件分离后,会更加清晰,可以有更多人开发脚本,方便调试。

    3、报告和日志文件输出

    执行了多少case,case结果如何,这都需要报告来展示,一般采用第三方插件来实现这个功能。好多报告格式是html,简单,明了的风格。日志输出也很重要,如果发生报错,脚本执行失败,通过日志快速定位发生问题位置。

    4、自定义的库的封装

    很多功能需要重复调用,可以写成一个公用方法,放到工具包下,每次方便调用,例如浏览器引擎类和basepage.py的封装。

    5、管理、执行脚本方式

    例如Python中单元测试框架unittest使用率非常高。

    6、第三方插件引入

    有时候,一些功能需要借助第三方插件,能够更好实现,例如AutoIT(来实现文件上传和下载)。还有利用第三方报告插件生成基于html格式的测试报告。

    7、持续集成

    git、svn、ant、maven,jenkins,我们会把这整合到jenkins,达到持续集成,一键执行测试脚本。

    总结

    一个简单的自动化测试框架,可能包含哪些组成部分:
    在这里插入图片描述

    1.3 为什么需要自动化测试框架?

    • 使自动化测试的实施更容易:一个好的自动化测试框架是可以让不那么懂技术的人也可以写自动化测试脚本。
    • 解决自动化测试脚本本身存在的问题:如异常处理和场景恢复。
    • 测试易于维护
    • 可重用性:可以实现一些通用功能,简化脚本开发过程。
    • 测试报告美观易读。

    1.4 判断是否需要自动化测试

    自动化测试成本投入高,风险大,并且不是所有的项目都适合自动化。自动化测试的优势在于反复迭代,它的价值产出在于长期的回归测试,以保证被测产品长期稳定地版本更新。

    • 适用项目:

      • 项目周期要长,且需求不会频繁变更。
      • 系统中多数对象要可以被识别,并且不存在大量第三方插件。

    2)自动化测试框架的类型

    2.1 自动化测试框架的分类

    下面是目前流行的各种类型的自动化测试框架。这些框架可能基于对不同关键因素(例如驱动类型、可重用性、易于维护等)进行自动化的支持而彼此不同。

    2.1.1 基于模块的测试框架:

    在这里插入图片描述

    这种框架将整个“测试中的应用程序”分为许多逻辑和独立的模块。对每个模块,创建一个独立的测试脚本,这些脚本结合在一起时,会构建成更大的测试脚本,代表多个模块,这些模块被抽象层隔开,这样在应用程序的各个部分所做的更改不会对该模块产生影响。

    • 缺点:在为每个模块实现测试脚本的同时,测试数据已经嵌入到测试脚本中,这导致使用不同的测试数据进行测试时需要在测试脚本中进行操作。

    2.1.2 库架构测试框架

    在这里插入图片描述
    库体系结构测试框架是建立在基于模块的测试框架之上,但比后者有一些额外的优势。它没有将测试的应用程序划分为测试脚本,而是划分为函数。因此,为测试中的应用程序创建一个由公共函数组成的公共库,当需要时,可以从测试脚本中调用这些库

    它的基本原理就是确定通用的步骤,并将这些步骤分组到公共库下的函数中,在需要的时候在测试脚本中调用这些函数。

    比如,一个登录的步骤,可以把它组合成一个函数,并保存到一个库中,登录时可以直接从库中调用这个函数,而不需要重新再编写代码。

    • 缺点:像基于模块的框架一样,测试数据嵌入测试脚本中,改变数据需要修改脚本;随着越来越多的库的引入,可能会使框架越来越复杂。

    2.1.3 数据驱动测试框架

    在这里插入图片描述
    数据驱动测试框架将测试脚本逻辑和测试数据彼此分离可以把测试数据单独存储起来,存储数据的可以是 xml文件、excel文件、文本文件、csv文件、ODBC数据库等。一般都是以 key-value 格式存储,方便获取使用。

    • 缺点:
      • 过程比较复杂,可能需要定制测试数据源格式和读取机制
      • 只有具有相同执行步骤集的相似测试用例才能组合成多组数据。不同的执行步骤集需要不同的测试用例

    2.1.4 关键字驱动测试框架

    在这里插入图片描述
    关键字驱动测试框架是对数据驱动测试框架的扩展,从某种意义上说,它不仅将测试数据从脚本中分离出来,它还将数据测试脚本的特定代码集保存到外部数据文件中。这些代码集被称为关键字,每个关键字都一种操作。关键字和测试数据都是独立于该框架

    • 缺点:
      • 需要懂得关键字的创建机制,从而可以自己开发关键字
      • 随着越来越多的关键字引入,可能会使框架逐渐变得复杂
      • 测试用例变得更长且复杂,从而影响测试用例的可维护性

    2.1.5 混合测试框架

    在这里插入图片描述
    混合测试框架就是上述(模块化,数据驱动和关键字驱动)多中类型框架的组合。就是利用各种类型框架的优点,组合起来的混合型测试框架。

    在这种框架中,通过将测试用例结合到模块化测试框架中,从模块化脚本中开发测试用例。每个测试用例都使用一个驱动程序脚本,该脚本使用数据驱动框架中的数据文件和关键字驱动框架中的操作文件。

    • 缺点:会比其他类型的测试框架更为复杂一些,例如阅读、维护等

    2.1.6 行为驱动开发框架

    行为驱动测试框架可以让开发人员、测试人员等以易于阅读和理解的格式实现功能验证的自动化。可通过自然语言来描述测试功能,测试场景,测试步骤,测试结果等。


    2.2 流行的自动化测试框架

    2.2.1 Robot Framework

    如果要使用python自动化测试框架进行测试自动化,则Robot Framework是最佳选择。Robot Framework是基于Python的,但是也可以使用 Jython(Java)或IronPython(.NET)语言进行脚本用例的编写。

    • Robot Framework使用关键字驱动的方法使测试用例易于创建。
    • Robot Framework还可以测试MongoDB、FTP、Android、Appium等。
    • 拥有非常多的测试库,包括Selenium WebDriver库和其他常用的的工具
    • Robot Framework具有许多API,可帮助使其尽可能地扩展。

    2.2.2 WebdriverIO

    WebdriverIO是基于Node.js的自动化测试框架。它具有集成的测试运行程序,可以为Web应用程序以及本机移动APP运行自动化测试用例。而且,WebdriverIO可以同时在WebDriver协议和Chrome Devtools协议上运行,从而使其对于基于Selenium Webdriver的跨浏览器测试或基于Chromium的自动化都非常有效。由于WebDriverIO是开源的,因此测试工程师可以获得一堆满足自动化需求的插件。

    2.2.3 Citrus

    Citrus是一个开源测试框架,测试人员可以使用该框架自动化针对任何消息传递协议或数据格式的集成测试。对于诸如REST、HTTP、SOAP或JMS之类的任何消息传递传输,Citrus测试框架都适用于测试消息传递集成。如果需要与用户界面进行交互然后验证后端过程,则可以将Citrus与Selenium进行集成

    2.2.4 Cypress

    Cypress是一个以开发人员为中心的测试自动化框架,该框架使TDD测试驱动开发对开发人员而言成为现实。它的设计原理是能够非常简单地将所有内容打包并捆绑在一起以进行整个端到端测试。Cypress的架构与Selenium不同。Selenium WebDriver在浏览器外部远程运行,而Cypress在其内部运行。这种方法有助于了解浏览器内部和外部发生的所有事情,以提供更一致的测试结果。

    2.2.5 Selenium

    Web应用程序中最受欢迎的开源测试自动化框架之一。Selenium具有跨平台和跨浏览器功能,它还可以用作许多其他测试工具的基础。Selenium支持多种编程语言,例如Java、C#、PHP、Python、Ruby等。它拥有最大的在线社区之一,因此更加易于维护。Selenium可以通过广泛的库和API进行高度扩展,以满足每个团队的需求。Selenium是测试人员首选的测试框架,因为可以编写更高级的测试脚本来满足各种复杂程度。它提供了用于测试创作的回放工具,而无需学习特定的脚本语言。

    2.2.6 Carina

    Carina使用流行的开源解决方案(如Appium、TestNG和Selenium)构建的,可减少对特定技术堆栈的依赖。测试人员可以测试APP(原生APP、混合APP、WebAPP)、WEB应用程序、REST服务和数据库。Carina框架支持不同类型的数据库,例如MySQL、SQL Server、Oracle、PostgreSQL,从而提供了使用MyBatis ORM框架实现DAO层的完美体验。Carina支持所有流行的浏览器和移动设备,并且在IOS/Android之间重用了高达80%的测试自动化代码。API测试基于Freemarker模板引擎,它在生成REST请求方面提供了极大的灵活性。Carina是跨平台的,可以在Unix或Windows OS上轻松运行测试用例。

    3)Selenium

    Selenium是一个用于Web应用程序测试的工具,是一套完整的web应用程序测试系统,包含了测试的录制(selenium IDE)、编写及运行(Selenium Remote Control)和测试的并行处理(Selenium Grid)。Selenium的核心Selenium Core基于JsUnit,完全由JavaScript编写,因此可以用于任何支持JavaScript的浏览器上。Selenium可以模拟真实浏览器,自动化测试工具,支持多种浏览器,爬虫中主要用来解决JavaScript渲染问题。

    这个工具的主要功能包括:测试与浏览器的兼容性,测试你的应用程序看是否能够很好得工作在不同浏览器和操作系统之上。

    • 优点:

      • 开源:不需要钱,且方便进行二次开发,例如提取对json和xml的处理来实现的数据驱动等。
      • 灵活性:因为更加入了xpath(当然大型项目的脚本里xpath 慎用,尽量取id或稳定的属性),加上配合IDE进行定位等,效果比较好。
      • 资料更全面,用该框架的公司越来越多。

    • 缺点:

      • 无论是RC还是Webdriver,对测试人员的编码水平有一定要求。
      • ant,testng,hudson使用也都是小众,大多数人执行这个框架前需要有较长时间学习适应。
      • 时间较短,不如QTP如此完善。

    3.1 selenium 1.0

    selenium 1.0 包括两部分:selenium server、 Client Libraries。

    支持的浏览器包括IE(7, 8, 9, 10, 11),Mozilla Firefox,Safari,Google Chrome,Opera,Edge等。

    3.1.1 selenium server

    selenium server负责控制浏览器的行为。主要有launcher,Http Proxy,selenium core。selenium core使用Selenium Server嵌入到浏览器页面中。实质上,selenium core是由JS函数组成,这样我们可以实现用程序对浏览器进行操作。

    3.1.2 client Libraries

    编写测试用例时控制selenium server的库。

    3.1.3 testcase的执行过程:

    在这里插入图片描述
    1、测试案例(Testcase)通过Client Lib的接口向Selenium Server(一个独立的中间服务器,确切地说是代理服务器)发送Http请求,要求和Selenium Server建立连接

    2、Selenium Server的Launcher启动浏览器,把Selenium Core加载入浏览器页面当中,并把浏览器的代理设置为Selenium Server的Http Proxy。

    3、Testcase通过Client Lib的接口向Selenium Server发送Http请求,Selenium Server对请求进行解析,然后通过Http Proxy发送JS命令通知Selenium Core执行操作浏览器的动作。

    4、Selenium Core接收到指令后,执行操作

    5、浏览器收到新的页面请求信息(因为在4中,Selenium Core的操作可能引发新的页面请求),于是发送Http请求,请求新的页面。由于Selenium Server在启动浏览器时做了手脚,所以Selenium Server会接收到所有由它启动的浏览器发送的请求

    6、Selenium Server接收到浏览器的发送的Http请求后,自己重组Http请求,获取对应的Web页面

    7、Selenium Server的Http Proxy把接收的Web页面返回给浏览器

    3.2 selenium 2.0(Webdriver)

    Selenium 2.0 将浏览器原生的API封装成WebDriver API,可以直接操作浏览器页面里的元素,甚至操作浏览器本身(截屏,窗口大小,启动,关闭,安装插件,配置证书之类的),所以就像真正的用户在操作一样。

    3.2.1 Selenium2的架构:

    在这里插入图片描述

    webdriver按照server–client的经典设计模式设计:

    • server端就是remote server,可以是任意的浏览器:我们的脚本启动浏览器后,该浏览器就是remote server,它的职责就是等待client发送请求并做出相应。
    • client端简单说来就是我们的测试代码:测试代码中的一些行为,比如打开浏览器,转跳到特定的url等操作是以http请求的方式发送给被server端(也就是被测浏览器)server接受请求,并执行相应操作,并在response中返回执行状态、返回值等信息

    3.2.2 WebDriver Wire

    the WebDriver Wire Protocol是Selenium自己设计定义的协议,这套协议非常之强大,几乎可以操作浏览器做任何事情,包括打开、关闭、最大化、最小化、元素定位、元素点击、上传文件等。

    WebDriver Wire协议是通用的,也就是说不管FirefoxDriver还是ChromeDriver,启动之后都会在某一个端口启动基于这套协议的Web Service。例如FirefoxDriver初始化成功,默认从http://localhost:7055开始,IE则是http://localhost:52432。

    3.2.3 webdriver的工作原理:

    1、启动浏览器后,selenium-webdriver会将目标浏览器绑定到特定的端口,启动后的浏览器则作为webdriver的remote server。

    2、客户端(也就是测试脚本),借助ComandExecutor发送HTTP请求给sever端(通信协议:The WebDriver Wire Protocol,在HTTP request的body中,会以WebDriver Wire协议规定的JSON格式的字符串来告诉Selenium我们希望浏览器接下来做什么事情)。

    3、Sever端需要依赖原生的浏览器组件,转化Web Service的命令为浏览器native的调用来完成操作。

    4)Appium

    Appium是一个开源的、跨平台的自动化测试工具,支持IOS、Android和FirefoxOS平台。 通过Appium,开发者无需重新编译app或者做任何调整,就可以测试移动应用,可以使测试代码访问后端API和数据库。它是通过驱动苹果的UIAutomation和Android的UiAutomator框架来实现的双平台支持,同时绑定了Selenium WebDriver用于老的Android平台测试。开发者可以使用WebDriver兼容的任何语言编写测试脚本,如Java, OC, JS, PHP,Python, Ruby, C#,Clojure 和Perl语言。

    4.1 UIAutomation

    UIAutomation是苹果提供的UI自动化测试框架,使用Javascript编写。

    基于UIAutomation有扩展型的工具框架和驱动型的框架:

    • 扩展型框架以JavaScript扩展库方法提供了很多好用js工具。
    • 注入式的框架通常会提供一些Lib或者是Framework,要求测试人员在待测应用的代码工程中导入这些内容,框架可以通过他们完成对app的驱动。
    • 驱动型UI Automation 在自动化测试底层使用了UI Automation库,通过TCP通信的方式驱动UI Automation来完成自动化测试,通过这种方式,编辑脚本的语言不再局限于JavaScript。

    Automation是Apple官方提供的UI自动化测试的解决方法,但接口不够丰富。

    4.2 UiAutomator

    UIAutomator是由谷歌提供的测试框架,它提供了原生Android app和游戏的高级UI测试。这是一个包含API的Java库,用来创建功能性UI测试,还有运行测试的执行引擎。该库自带Android SDK。

    • 优点:它在运行访问不同的进程时,会给JUnit测试案例特权。库由谷歌社区支持和维护。
    • 缺点:仅支持android4.1(API level 16)及以上。 不支持脚本记录。 支持的重点是Java。

    如自动化测试中有跨APP操作,可以结合UiAutomator实现。



    【部分内容参考自】

    • 什么是自动化测试框架:https://blog.csdn.net/m0_52650621/article/details/110195874
    • Python+Selenium框架设计篇之-什么是自动化测试框架:https://www.cnblogs.com/wangyinghao/p/10607475.html
    • 自动化测试为什么需要框架?:https://blog.csdn.net/kami_ochin_akane/article/details/109480295
    • 自动化测试框架总结:https://www.jianshu.com/p/7239eff75e68
    • 关于自动化测试框架:https://www.cnblogs.com/delav/p/12707396.html
    展开全文
  • 1、支持多并行测试 2、支持所有的云解决方案,如 BrowserStack,SauceLabs,Testingbot 3、数据驱动测试 4、一步级报告生成 5、自动屏幕快照的失败的测试步骤 ...8、自动重新运行失败的测试用例...
  • 5种比较常见的自动化测试框架

    千次阅读 2020-10-26 14:34:43
    自动化测试框架

    每一个测试人员都应该了解每种框架的优缺点,以帮助你的团队更好地确定最适合的测试的框架,以达到事半功倍。

    什么是测试自动化框架?

    自动化测试框架就是用于测试自动化的框架。具体来说,它提供了自动化测试用例编写、自动化测试用例执行、自动化测试报告生成等基础功能。我们只需要基于这个框架,完成和业务高度相关的测试用例设计和实现即可。另外,框架会为我们处理好复杂度与扩展性的问题,我们无需为此操心。

    测试自动化框架是在创建和设计测试用例时使用的一组最佳实践或准则。

    测试准则集可以包括编码标准,对象存储库,测试数据处理方法,有关外部存储访问的信息等。

    这些准则并非强制,但是在自动化脚本过程中,它们提高了测试的效率并产生了有益的结果。

    如果对软件测试、接口、自动化、性能测试、测试开发、面试经验交流。感兴趣可以810119819,群内会有不定期的发放免费的资料链接,这些资料都是从各个技术网站搜集、整理出来的,如果你有好的学习资料可以私聊发我,我会注明出处之后分享给大家。

    使用测试自动化框架的好处

    • 更全的测试范围

      降低脚本维护成本

      节省人力成本

      提高测试速度和效率

      可重用的测试代码

      易于报告

    根据需求使用适配的自动化测试框架有助于加快测试过程,并消除人为错误。它还使测试维护更加容易,加快测试进度,节省成本、时间和精力。此外,框架QA团队能够充分开发、执行和报告测试过程,同时还使代码可在多种情况下重用。

    5种最流行的自动化测试框架类型

    团队根据团队规模、经验水平、用户需求等因素来选择测试框架。以下是五种最流行的框架及其优缺点:

    1、线性框架
    这是最基本的框架类型。它通常被称为“记录和回放(record and playback)”框架。

    在这个过程中,测试代码的创建和执行是按线性或顺序编写的——测试人员手动记录每一个步骤,并自动回放记录的脚本。这些步骤包括导航、用户输入和检查点。它最适合小型应用程序或团队。

    在此过程中,测试代码的创建和执行以线性或顺序方式编写-测试人员手动记录每个步骤并自动播放记录的脚本。这些步骤包括导航,用户输入和检查点。最适合小型应用程序或小团队。

    优点:

    线性框架最大的好处是生成测试用例的速度快,直接录制;无须代码基础,无须手动编写测试代码,因此门槛较低、易于上手。

    缺点:

    然而线性框架的不足之处也很明显:录制的脚本是固定的(hardcode),不可重用。这意味着,当应用发生微小变化时,上一次录制的脚本可能就无法使用了,需要重新录制(rework),从而产生大量的后期维护成本。

    2、基于模块化的框架
    顾名思义,此框架允许将被测应用程序划分为单独的模块,单元或部分。每个模块都会为它们创建独立的测试脚本。因此,每个模块及其测试脚本的组合可以构建代表各种测试案例的更大的测试。

    优点:

    该框架在创建模块时使用抽象。因此,应用程序更改将只影响与它们相关联的测试脚本所涉及的模块,而不影响其他部分。

    高度的模块化,这使得维护更加容易且具有成本效益

    创建测试用例所需的精力最少,因为可以重复使用不同模块的测试脚本。

    缺点:

    如果没有语言开发基础,则建立框架可能会很困难。

    由于将数据硬编码到测试脚本中,因此无法重复使用数据集——因为测试是单独执行的。

    3、库结构框架
    该库体系结构框架建立在模块化框架的基础上,但具有其他好处。这样做的好处是,它不仅可以将被测应用程序划分为测试脚本,还可以将测试脚本中的相似任务划分为通用功能。

    然后创建一个库,该库构成了AUT的常用功能,可以在需要时由测试脚本调用。

    优点:

    高度的模块化,这使得测试维护简单且预算友好。

    它具有高度的可重用性,因为它的公共函数库可以被几个测试脚本使用。

    缺点:

    框架中引入的库使其更加复杂。

    测试数据也被硬编码到测试脚本中。因此,数据中的更改必须适用于测试脚本。

    测试脚本的开发需要更多的时间和技术。

    4、数据驱动框架
    在数据驱动框架中,测试数据和测试脚本是分离的。在许多测试场景中,需要使用不同的测试数据多次测试同一功能或特性。如果测试数据是hardcode进测试脚本的,那么每更换一次测试数据都需要修改测试脚本。这是很大的工作量。此时,可以使用数据驱动框架。具体来说,测试脚本是固定的,而测试数据可以从外部的数据文件,以Excel、CSV、SQL等形式作为参数传入测试脚本。这样,我们只需要维护一份脚本和一份数据文件即可。

    优点:

    总体来说,这种框架最大的好处就是易于维护。

    测试脚本中的任何更改都不会影响测试数据。因此,可以避免对数据进行硬编码。

    可以使用多组数据进行测试。

    可以通过更改外部数据库中的测试数据来测试各种测试方案,从而减少所需的测试脚本数量。

    缺点:

    准备和计划框架的通用测试脚本,识别与格式化测试数据需要花费时间。

    框架设计的使用需要经验丰富的测试人员,因为它的复杂性,需要具备多种编程语言知识。

    如果对软件测试、接口、自动化、性能测试、测试开发、面试经验交流。感兴趣可以810119819,群内会有不定期的发放免费的资料链接,这些资料都是从各个技术网站搜集、整理出来的,如果你有好的学习资料可以私聊发我,我会注明出处之后分享给大家。

    5、关键字驱动框架

    该框架是数据驱动框架的扩展。测试数据和测试脚本也被分离,不同的是,该框架要更进一步地将测试脚本中的通用功能剥离出来,形成关键词(keyword)。测试脚本本质上就是对一系列通用的或者自定义的关键词的调用。这样做的好处是关键词可以在多个测试中复用,并且测试脚本更加易于维护。不过,实现这样一个框架并非易事。

    优点:

    与数据驱动不同,运行此框架不需要脚本知识。

    可以独立于被测应用程序构建测试脚本。

    一个关键字可以在多个测试脚本中使用。因此该代码是可重用的。

    缺点:

    设计框架和维护关键字对自动化的专业知识要求比较高。

    实现该框架的成本相对较高,而且设置起来也比较耗时和复杂。

    综上所述,实现用于自动化测试的框架需要选择一种灵活的工具。该工具应支持广泛的应用程序,并满足测试要求。另外,应该有正确的策略来定义应该自动化哪些部分。

    需要指出的是,业界已经有了实现上述各种测试自动化框架的工具。通常来说,我们并不需要重新发明一个新的框架,而是基于已有的框架去进行优化升级,使之适合自己的项目需求,来完成自动化测试工作。

    那么,面对一个新的自动化测试框架,如何着手工作呢?

    我们应该聚焦在以下四个问题上。

    1、如何生成测试用例?
    不同的框架,生成测试用例的方法不一样。

    对于线性框架来说,无须编写脚本,只需要点击预设的按钮就能够生成测试用例;比如Katalon,直接录制生成测试用例。

    对于多数框架来说,生成测试用例需要编程。当然,不同框架使用的编程语言、编程风格有差异。

    对于Selenium框架来说,使用的是通用编程语言Java和Python,可能更多的是对Selenium进行二次封装,以便更好更快的生成用例;

    对于Robot Framework来说,使用的是其专用的Robot Framework编程语言。

    一般来说,使用框架编程的过程很多时候就是调用库接口的过程。因此作为前提,在编写用例之前,我们需要熟悉框架提供的库的种类和功能,以及这些库所提供的API的使用方法。

    2、如何执行测试用例?
    当测试用例完成之后,我们需要运行测试用例。

    自动化测试是通过GUI图形界面来触发,还是通过CLI命令触发,这因框架而异。

    当然,仅仅知道如何触发测试是不够的。我们通常有更多的需求。

    例如,如何选择性地执行满足特定条件的测试用例子集?

    如何设置全局的执行参数(超时时间、日志路径、报告形式等)?

    如何动态地给测试用例集传入参数?

    一般来说,一个完整的框架需要提供足够多的控制选项,从而让我们根据需求定制执行测试的方式。

    以Robot Framework为例,其执行用例的命令具有30多个不同的选项。

    这提供了足够的自由度和一些非常棒的功能。例如其dryrun选项,可以让我们在不实际执行用例的情况下,快速检查出测试用例中参数不匹配、语法不正确、关键词找不到、库导入失败等错误,非常实用。

    3、如何检查测试结果?
    测试执行结束之后,我们需要关注测试结果。不同的框架会以不同形式提供测试结果。例如,测试结果既能以控制台日志的形式体现、也能够以图表和报告的形式体现,并以邮件发送或者展示在网站上。

    根据测试结果,我们可以很容易地了解测试的执行情况,包括测试的成功/失败情况、测试的整体/局部用时等。

    当测试失败时,我们尤其需要关注测试失败的具体情况。

    通常,我们关心失败是由于我们使用框架的方法不当造成的,还是由于被测软件的质量问题。这一点,只能通过检查和分析测试结果得到。

    4、如何扩展测试框架?
    一般来说,框架只是提供了最基本的功能。很多时候,框架并不能直接满足自动化测试的需求。这时我们可以寻求第三方的、与框架本身兼容的库或者插件。如果第三方工具不能满足我们的需求,我们就需要开发自己的库和工具。

    例如,对于HTTP、SSH等公有协议,我们很容易在网络上找到某个框架的第三方库;

    而对于只用于公司产品的私有协议,我们通常无法找到第三方库,只能自己开发。

    自己开发时,需要注意的是要遵从框架的规范,使得开发出的库能够与框架无缝兼容。

    说在最后,选择了一个框架,在享受其好处时,也不得不承受其不足。

    如果对软件测试、接口、自动化、性能测试、测试开发、面试经验交流。感兴趣可以810119819,群内会有不定期的发放免费的资料链接,这些资料都是从各个技术网站搜集、整理出来的,如果你有好的学习资料可以私聊发我,我会注明出处之后分享给大家。

    如果我们的关键需求受制于框架,并且框架也不容易扩展,那么我们就可能需要开发自己的框架。这是一件投入较大的事情。在大多数情况下,还是建议重用和有限扩展已有的框架。毕竟,不要重新发明轮子——Don’t reinvent the wheel!

    展开全文
  • 完整的框架源码下载...一、Python+unittest+requests+HTMLTestRunner 完整的接口自动化测试框架搭建_00——框架结构简解 首先配置好开发环境,下载安装Python并...

    完整的框架源码下载 https://gitee.com/submi_to/interfaceTest/tree/develop/,欢迎添加我的微信,相互学习探讨~1305618688,qq交流群:849102042

    一、Python+unittest+requests+HTMLTestRunner 完整的接口自动化测试框架搭建_00——框架结构简解

     首先配置好开发环境,下载安装Python并下载安装pycharm,在pycharm中创建项目功能目录。如果不会的可以百度Google一下,该内容网上的讲解还是比较多比较全的!

    大家可以先简单了解下该项目的目录结构介绍,后面会针对每个文件有详细注解和代码。

    common:

    ——configDb.py:这个文件主要编写数据库连接池的相关内容,本项目暂未考虑使用数据库来存储读取数据,此文件可忽略,或者不创建。本人是留着以后如果有相关操作时,方便使用。

    ——configEmail.py:这个文件主要是配置发送邮件的主题、正文等,将测试报告发送并抄送到相关人邮箱的逻辑。

    ——configHttp.py:这个文件主要来通过get、post、put、delete等方法来进行http请求,并拿到请求响应。

    ——HTMLTestRunner.py:主要是生成测试报告相关

    ——Log.py:调用该类的方法,用来打印生成日志

    result:

    ——logs:生成的日志文件

    ——report.html:生成的测试报告

    testCase:

    ——test01case.py:读取userCase.xlsx中的用例,使用unittest来进行断言校验

    testFile/case:

    ——userCase.xlsx:对下面test_api.py接口服务里的接口,设计了三条简单的测试用例,如参数为null,参数不正确等

    caselist.txt:配置将要执行testCase目录下的哪些用例文件,前加#代表不进行执行。当项目过于庞大,用例足够多的时候,我们可以通过这个开关,来确定本次执行哪些接口的哪些用例。

    config.ini:数据库、邮箱、接口等的配置项,用于方便的调用读取。

    getpathInfo.py:获取项目绝对路径

    geturlParams.py:获取接口的URL、参数、method等

    readConfig.py:读取配置文件的方法,并返回文件中内容

    readExcel.py:读取Excel的方法

    runAll.py:开始执行接口自动化,项目工程部署完毕后直接运行该文件即可

    test_api.py:自己写的提供本地测试的接口服务

    test_sql.py:测试数据库连接池的文件,本次项目未用到数据库,可以忽略

    二、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_01——测试接口服务

    首先,我们想搭建一个接口自动化测试框架,前提我们必须要有一个可支持测试的接口服务。有人可能会说,现在我们的环境不管测试环境,还是生产环境有现成的接口。但是,一般工作环境中的接口,不太满足我们框架的各种条件。举例如,接口a可能是get接口b可能又是post,等等等等。因此我决定自己写一个简单的接口!用于我们这个框架的测试!

    按第一讲的目录创建好文件,打开test_api.py,写入如下代码

    import flask
    import json
    from flask import request
    
    '''
    flask: web框架,通过flask提供的装饰器@server.route()将普通函数转换为服
    '''
    # 创建一个服务,把当前这个python文件当做一个服务
    server = flask.Flask(__name__)
    # @server.route()可以将普通函数转变为服务 登录接口的路径、请求方式
    @server.route('/login', methods=['get', 'post'])
    def login():
        # 获取通过url请求传参的数据
        username = request.values.get('name')
        # 获取url请求传的密码,明文
        pwd = request.values.get('pwd')
        # 判断用户名、密码都不为空
        if username and pwd:
            if username == 'xiaoming' and pwd == '111':
                resu = {'code': 200, 'message': '登录成功'}
                return json.dumps(resu, ensure_ascii=False)  # 将字典转换字符串
            else:
                resu = {'code': -1, 'message': '账号密码错误'}
                return json.dumps(resu, ensure_ascii=False)
        else:
            resu = {'code': 10001, 'message': '参数不能为空!'}
            return json.dumps(resu, ensure_ascii=False)
    
    if __name__ == '__main__':
        server.run(debug=True, port=8888, host='127.0.0.1')
    
    

    执行test_api.py,在浏览器中输入http://127.0.0.1:8888/login?name=xiaoming&pwd=11199回车,验证我们的接口服务是否正常~

    变更我们的参数,查看不同的响应结果确认接口服务一切正常

    三、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_02——配置文件读取

    在我们第二讲中,我们已经通过flask这个web框架创建好了我们用于测试的接口服务,因此我们可以把这个接口抽出来一些参数放到配置文件,然后通过一个读取配置文件的方法,方便后续的使用。同样还有邮件的相关配置~

    按第一讲的目录创建好config.ini文件,打开该文件写入如下:

    # -*- coding: utf-8 -*-
    [HTTP]
    scheme = http
    baseurl = 127.0.0.1
    port = 8888
    timeout = 10.0
    
    
    
    [EMAIL]
    on_off = on;
    subject = 接口自动化测试报告
    app = Outlook
    addressee = songxiaobao@qq.com
    cc = zhaobenshan@qq.com

    在HTTP中,协议http,baseURL,端口,超时时间。

    在邮件中on_off是设置的一个开关,=on打开,发送邮件,=其他不发送邮件。subject邮件主题,addressee收件人,cc抄送人。

    在我们编写readConfig.py文件前,我们先写一个获取项目某路径下某文件绝对路径的一个方法。按第一讲的目录结构创建好getpathInfo.py,打开该文件

    import os
    
    def get_Path():
        path = os.path.split(os.path.realpath(__file__))[0]
        return path
    
    if __name__ == '__main__':# 执行该文件,测试下是否OK
        print('测试路径是否OK,路径为:', get_Path())
    

    填写如上代码并执行后,查看输出结果,打印出了该项目的绝对路径:

    继续往下走,同理,按第一讲目录创建好readConfig.py文件,打开该文件,以后的章节不在累赘

    import os
    import configparser
    import getpathInfo#引入我们自己的写的获取路径的类
    
    path = getpathInfo.get_Path()#调用实例化,还记得这个类返回的路径为C:\Users\songlihui\PycharmProjects\dkxinterfaceTest
    config_path = os.path.join(path, 'config.ini')#这句话是在path路径下再加一级,最后变成C:\Users\songlihui\PycharmProjects\dkxinterfaceTest\config.ini
    config = configparser.ConfigParser()#调用外部的读取配置文件的方法
    config.read(config_path, encoding='utf-8')
    
    class ReadConfig():
    
        def get_http(self, name):
            value = config.get('HTTP', name)
            return value
        def get_email(self, name):
            value = config.get('EMAIL', name)
            return value
        def get_mysql(self, name):#写好,留以后备用。但是因为我们没有对数据库的操作,所以这个可以屏蔽掉
            value = config.get('DATABASE', name)
            return value
    
    
    if __name__ == '__main__':#测试一下,我们读取配置文件的方法是否可用
        print('HTTP中的baseurl值为:', ReadConfig().get_http('baseurl'))
        print('EMAIL中的开关on_off值为:', ReadConfig().get_email('on_off'))

    执行下readConfig.py,查看数据是否正确

    一切OK

    四、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_03——读取Excel中的case

    配置文件写好了,接口我们也有了,然后我们来根据我们的接口设计我们简单的几条用例。首先在前两讲中我们写了一个我们测试的接口服务,针对这个接口服务存在三种情况的校验。正确的用户名和密码,账号密码错误和账号密码为空

    我们根据上面的三种情况,将对这个接口的用例写在一个对应的单独文件中testFile\case\userCase.xlsx ,userCase.xlsx内容如下:

    紧接着,我们有了用例设计的Excel了,我们要对这个Excel进行数据的读取操作,继续往下,我们创建readExcel.py文件

    import os
    import getpathInfo# 自己定义的内部类,该类返回项目的绝对路径
    #调用读Excel的第三方库xlrd
    from xlrd import open_workbook
    # 拿到该项目所在的绝对路径
    path = getpathInfo.get_Path()
    
    class readExcel():
        def get_xls(self, xls_name, sheet_name):# xls_name填写用例的Excel名称 sheet_name该Excel的sheet名称
            cls = []
            # 获取用例文件路径
            xlsPath = os.path.join(path, "testFile", 'case', xls_name)
            file = open_workbook(xlsPath)# 打开用例Excel
            sheet = file.sheet_by_name(sheet_name)#获得打开Excel的sheet
            # 获取这个sheet内容行数
            nrows = sheet.nrows
            for i in range(nrows):#根据行数做循环
                if sheet.row_values(i)[0] != u'case_name':#如果这个Excel的这个sheet的第i行的第一列不等于case_name那么我们把这行的数据添加到cls[]
                    cls.append(sheet.row_values(i))
            return cls
    if __name__ == '__main__':#我们执行该文件测试一下是否可以正确获取Excel中的值
        print(readExcel().get_xls('userCase.xlsx', 'login'))
        print(readExcel().get_xls('userCase.xlsx', 'login')[0][1])
        print(readExcel().get_xls('userCase.xlsx', 'login')[1][2])

    结果为:

    完全正确~

    五、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_04——requests请求

    配置文件有了,读取配置文件有了,用例有了,读取用例有了,我们的接口服务有了,我们是不是该写对某个接口进行http请求了,这时候我们需要使用pip install requests来安装第三方库,在common下configHttp.py,configHttp.py的内容如下:

    import requests
    import json
    
    
    class RunMain():
    
        def send_post(self, url, data):  # 定义一个方法,传入需要的参数url和data
            # 参数必须按照url、data顺序传入
            result = requests.post(url=url, data=data).json()  # 因为这里要封装post方法,所以这里的url和data值不能写死
            res = json.dumps(result, ensure_ascii=False, sort_keys=True, indent=2)
            return res
    
        def send_get(self, url, data):
            result = requests.get(url=url, params=data).json()
            res = json.dumps(result, ensure_ascii=False, sort_keys=True, indent=2)
            return res
    
        def run_main(self, method, url=None, data=None):  # 定义一个run_main函数,通过传过来的method来进行不同的get或post请求
            result = None
            if method == 'post':
                result = self.send_post(url, data)
            elif method == 'get':
                result = self.send_get(url, data)
            else:
                print("method值错误!!!")
            return result
    
    
    if __name__ == '__main__':  # 通过写死参数,来验证我们写的请求是否正确
        result1 = RunMain().run_main('post', 'http://127.0.0.1:8888/login', {'name': 'xiaoming','pwd':'111'})
        result2 = RunMain().run_main('get', 'http://127.0.0.1:8888/login', 'name=xiaoming&pwd=111')
        print(result1)
        print(result2)

    执行该文件,验证结果正确性:

    我们发现和浏览器中进行请求该接口,得到的结果一致,说明没有问题,一切OK

    六、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_05——参数动态化

    在上一讲中,我们写了针对我们的接口服务,设计的三种测试用例,使用写死的参数(result = RunMain().run_main('post', 'http://127.0.0.1:8888/login', 'name=xiaoming&pwd='))来进行requests请求。本讲中我们写一个类,来用于分别获取这些参数,来第一讲的目录创建geturlParams.py,geturlParams.py文件中的内容如下:

    import readConfig as readConfig
    
    readconfig = readConfig.ReadConfig()
    
    class geturlParams():# 定义一个方法,将从配置文件中读取的进行拼接
        def get_Url(self):
            new_url = readconfig.get_http('scheme') + '://' + readconfig.get_http('baseurl') + ':8888' + '/login' + '?'
            #logger.info('new_url'+new_url)
            return new_url
    
    if __name__ == '__main__':# 验证拼接后的正确性
        print(geturlParams().get_Url())

    通过将配置文件中的进行拼接,拼接后的结果:http://127.0.0.1:8888/login?和我们请求的一致

    七、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_06——unittest断言

    以上的我们都准备好了,剩下的该写我们的unittest断言测试case了,在testCase下创建test01case.py文件,文件中内容如下:

    import json
    import unittest
    from common.configHttp import RunMain
    import paramunittest
    import geturlParams
    import urllib.parse
    # import pythoncom
    import readExcel
    # pythoncom.CoInitialize()
    
    url = geturlParams.geturlParams().get_Url()# 调用我们的geturlParams获取我们拼接的URL
    login_xls = readExcel.readExcel().get_xls('userCase.xlsx', 'login')
    
    @paramunittest.parametrized(*login_xls)
    class testUserLogin(unittest.TestCase):
        def setParameters(self, case_name, path, query, method):
            """
            set params
            :param case_name:
            :param path
            :param query
            :param method
            :return:
            """
            self.case_name = str(case_name)
            self.path = str(path)
            self.query = str(query)
            self.method = str(method)
    
        def description(self):
            """
            test report description
            :return:
            """
            self.case_name
    
        def setUp(self):
            """
    
            :return:
            """
            print(self.case_name+"测试开始前准备")
    
        def test01case(self):
            self.checkResult()
    
        def tearDown(self):
            print("测试结束,输出log完结\n\n")
    
        def checkResult(self):# 断言
            """
            check test result
            :return:
            """
            url1 = "http://www.xxx.com/login?"
            new_url = url1 + self.query
            data1 = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(new_url).query))# 将一个完整的URL中的name=&pwd=转换为{'name':'xxx','pwd':'bbb'}
            info = RunMain().run_main(self.method, url, data1)# 根据Excel中的method调用run_main来进行requests请求,并拿到响应
            ss = json.loads(info)# 将响应转换为字典格式
            if self.case_name == 'login':# 如果case_name是login,说明合法,返回的code应该为200
                self.assertEqual(ss['code'], 200)
            if self.case_name == 'login_error':# 同上
                self.assertEqual(ss['code'], -1)
            if self.case_name == 'login_null':# 同上
                self.assertEqual(ss['code'], 10001)

    八、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_07——HTMLTestRunner

    按我的目录结构,在common下创建HTMLTestRunner.py文件,内容如下:

    # -*- coding: utf-8 -*-
    """
    A TestRunner for use with the Python unit testing framework. It
    generates a HTML report to show the result at a glance.
    The simplest way to use this is to invoke its main method. E.g.
        import unittest
        import HTMLTestRunner
        ... define your tests ...
        if __name__ == '__main__':
            HTMLTestRunner.main()
    For more customization options, instantiates a HTMLTestRunner object.
    HTMLTestRunner is a counterpart to unittest's TextTestRunner. E.g.
        # output to a file
        fp = file('my_report.html', 'wb')
        runner = HTMLTestRunner.HTMLTestRunner(
                    stream=fp,
                    title='My unit test',
                    description='This demonstrates the report output by HTMLTestRunner.'
                    )
        # Use an external stylesheet.
        # See the Template_mixin class for more customizable options
        runner.STYLESHEET_TMPL = '<link rel="stylesheet" href="my_stylesheet.css" type="text/css">'
        # run the test
        runner.run(my_test_suite)
    ------------------------------------------------------------------------
    Copyright (c) 2004-2007, Wai Yip Tung
    All rights reserved.
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are
    met:
    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name Wai Yip Tung nor the names of its contributors may be
      used to endorse or promote products derived from this software without
      specific prior written permission.
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    """
    
    # URL: http://tungwaiyip.info/software/HTMLTestRunner.html
    
    __author__ = "Wai Yip Tung"
    __version__ = "0.9.1"
    
    """
    Change History
    Version 0.9.1
    * 用Echarts添加执行情况统计图 (灰蓝)
    Version 0.9.0
    * 改成Python 3.x (灰蓝)
    Version 0.8.3
    * 使用 Bootstrap稍加美化 (灰蓝)
    * 改为中文 (灰蓝)
    Version 0.8.2
    * Show output inline instead of popup window (Viorel Lupu).
    Version in 0.8.1
    * Validated XHTML (Wolfgang Borgert).
    * Added description of test classes and test cases.
    Version in 0.8.0
    * Define Template_mixin class for customization.
    * Workaround a IE 6 bug that it does not treat <script> block as CDATA.
    Version in 0.7.1
    * Back port to Python 2.3 (Frank Horowitz).
    * Fix missing scroll bars in detail log (Podi).
    """
    
    # TODO: color stderr
    # TODO: simplify javascript using ,ore than 1 class in the class attribute?
    
    import datetime
    import sys
    import io
    import time
    import unittest
    from xml.sax import saxutils
    
    
    # ------------------------------------------------------------------------
    # The redirectors below are used to capture output during testing. Output
    # sent to sys.stdout and sys.stderr are automatically captured. However
    # in some cases sys.stdout is already cached before HTMLTestRunner is
    # invoked (e.g. calling logging.basicConfig). In order to capture those
    # output, use the redirectors for the cached stream.
    #
    # e.g.
    #   >>> logging.basicConfig(stream=HTMLTestRunner.stdout_redirector)
    #   >>>
    
    class OutputRedirector(object):
        """ Wrapper to redirect stdout or stderr """
    
        def __init__(self, fp):
            self.fp = fp
    
        def write(self, s):
            self.fp.write(s)
    
        def writelines(self, lines):
            self.fp.writelines(lines)
    
        def flush(self):
            self.fp.flush()
    
    
    stdout_redirector = OutputRedirector(sys.stdout)
    stderr_redirector = OutputRedirector(sys.stderr)
    
    
    # ----------------------------------------------------------------------
    # Template
    
    
    class Template_mixin(object):
        """
        Define a HTML template for report customerization and generation.
        Overall structure of an HTML report
        HTML
        +------------------------+
        |<html>                  |
        |  <head>                |
        |                        |
        |   STYLESHEET           |
        |   +----------------+   |
        |   |                |   |
        |   +----------------+   |
        |                        |
        |  </head>               |
        |                        |
        |  <body>                |
        |                        |
        |   HEADING              |
        |   +----------------+   |
        |   |                |   |
        |   +----------------+   |
        |                        |
        |   REPORT               |
        |   +----------------+   |
        |   |                |   |
        |   +----------------+   |
        |                        |
        |   ENDING               |
        |   +----------------+   |
        |   |                |   |
        |   +----------------+   |
        |                        |
        |  </body>               |
        |</html>                 |
        +------------------------+
        """
    
        STATUS = {
            0: u'通过',
            1: u'失败',
            2: u'错误',
        }
    
        DEFAULT_TITLE = 'Unit Test Report'
        DEFAULT_DESCRIPTION = ''
    
        # ------------------------------------------------------------------------
        # HTML Template
    
        HTML_TMPL = r"""<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    <html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>%(title)s</title>
        <meta name="generator" content="%(generator)s"/>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    
        <link href="http://cdn.bootcss.com/bootstrap/3.3.0/css/bootstrap.min.css" rel="stylesheet">
        <script src="https://cdn.bootcss.com/echarts/3.8.5/echarts.common.min.js"></script>
        <!-- <script type="text/javascript" src="js/echarts.common.min.js"></script> -->
    
        %(stylesheet)s
    
    </head>
    <body>
        <script language="javascript" type="text/javascript"><!--
        output_list = Array();
        /* level - 0:Summary; 1:Failed; 2:All */
        function showCase(level) {
            trs = document.getElementsByTagName("tr");
            for (var i = 0; i < trs.length; i++) {
                tr = trs[i];
                id = tr.id;
                if (id.substr(0,2) == 'ft') {
                    if (level < 1) {
                        tr.className = 'hiddenRow';
                    }
                    else {
                        tr.className = '';
                    }
                }
                if (id.substr(0,2) == 'pt') {
                    if (level > 1) {
                        tr.className = '';
                    }
                    else {
                        tr.className = 'hiddenRow';
                    }
                }
            }
        }
        function showClassDetail(cid, count) {
            var id_list = Array(count);
            var toHide = 1;
            for (var i = 0; i < count; i++) {
                tid0 = 't' + cid.substr(1) + '.' + (i+1);
                tid = 'f' + tid0;
                tr = document.getElementById(tid);
                if (!tr) {
                    tid = 'p' + tid0;
                    tr = document.getElementById(tid);
                }
                id_list[i] = tid;
                if (tr.className) {
                    toHide = 0;
                }
            }
            for (var i = 0; i < count; i++) {
                tid = id_list[i];
                if (toHide) {
                    document.getElementById('div_'+tid).style.display = 'none'
                    document.getElementById(tid).className = 'hiddenRow';
                }
                else {
                    document.getElementById(tid).className = '';
                }
            }
        }
        function showTestDetail(div_id){
            var details_div = document.getElementById(div_id)
            var displayState = details_div.style.display
            // alert(displayState)
            if (displayState != 'block' ) {
                displayState = 'block'
                details_div.style.display = 'block'
            }
            else {
                details_div.style.display = 'none'
            }
        }
        function html_escape(s) {
            s = s.replace(/&/g,'&amp;');
            s = s.replace(/</g,'&lt;');
            s = s.replace(/>/g,'&gt;');
            return s;
        }
        /* obsoleted by detail in <div>
        function showOutput(id, name) {
            var w = window.open("", //url
                            name,
                            "resizable,scrollbars,status,width=800,height=450");
            d = w.document;
            d.write("<pre>");
            d.write(html_escape(output_list[id]));
            d.write("\n");
            d.write("<a href='javascript:window.close()'>close</a>\n");
            d.write("</pre>\n");
            d.close();
        }
        */
        --></script>
        <div id="div_base">
            %(heading)s
            %(report)s
            %(ending)s
            %(chart_script)s
        </div>
    </body>
    </html>
    """  # variables: (title, generator, stylesheet, heading, report, ending, chart_script)
    
        ECHARTS_SCRIPT = """
        <script type="text/javascript">
            // 基于准备好的dom,初始化echarts实例
            var myChart = echarts.init(document.getElementById('chart'));
            // 指定图表的配置项和数据
            var option = {
                title : {
                    text: '测试执行情况',
                    x:'center'
                },
                tooltip : {
                    trigger: 'item',
                    formatter: "{a} <br/>{b} : {c} ({d}%%)"
                },
                color: ['#95b75d', 'grey', '#b64645'],
                legend: {
                    orient: 'vertical',
                    left: 'left',
                    data: ['通过','失败','错误']
                },
                series : [
                    {
                        name: '测试执行情况',
                        type: 'pie',
                        radius : '60%%',
                        center: ['50%%', '60%%'],
                        data:[
                            {value:%(Pass)s, name:'通过'},
                            {value:%(fail)s, name:'失败'},
                            {value:%(error)s, name:'错误'}
                        ],
                        itemStyle: {
                            emphasis: {
                                shadowBlur: 10,
                                shadowOffsetX: 0,
                                shadowColor: 'rgba(0, 0, 0, 0.5)'
                            }
                        }
                    }
                ]
            };
            // 使用刚指定的配置项和数据显示图表。
            myChart.setOption(option);
        </script>
        """  # variables: (Pass, fail, error)
    
        # ------------------------------------------------------------------------
        # Stylesheet
        #
        # alternatively use a <link> for external style sheet, e.g.
        #   <link rel="stylesheet" href="$url" type="text/css">
    
        STYLESHEET_TMPL = """
    <style type="text/css" media="screen">
        body        { font-family: Microsoft YaHei,Consolas,arial,sans-serif; font-size: 80%; }
        table       { font-size: 100%; }
        pre         { white-space: pre-wrap;word-wrap: break-word; }
        /* -- heading ---------------------------------------------------------------------- */
        h1 {
            font-size: 16pt;
            color: gray;
        }
        .heading {
            margin-top: 0ex;
            margin-bottom: 1ex;
        }
        .heading .attribute {
            margin-top: 1ex;
            margin-bottom: 0;
        }
        .heading .description {
            margin-top: 2ex;
            margin-bottom: 3ex;
        }
        /* -- css div popup ------------------------------------------------------------------------ */
        a.popup_link {
        }
        a.popup_link:hover {
            color: red;
        }
        .popup_window {
            display: none;
            position: relative;
            left: 0px;
            top: 0px;
            /*border: solid #627173 1px; */
            padding: 10px;
            /*background-color: #E6E6D6; */
            font-family: "Lucida Console", "Courier New", Courier, monospace;
            text-align: left;
            font-size: 8pt;
            /* width: 500px;*/
        }
        }
        /* -- report ------------------------------------------------------------------------ */
        #show_detail_line {
            margin-top: 3ex;
            margin-bottom: 1ex;
        }
        #result_table {
            width: 99%;
        }
        #header_row {
            font-weight: bold;
            color: #303641;
            background-color: #ebebeb;
        }
        #total_row  { font-weight: bold; }
        .passClass  { background-color: #bdedbc; }
        .failClass  { background-color: #ffefa4; }
        .errorClass { background-color: #ffc9c9; }
        .passCase   { color: #6c6; }
        .failCase   { color: #FF6600; font-weight: bold; }
        .errorCase  { color: #c00; font-weight: bold; }
        .hiddenRow  { display: none; }
        .testcase   { margin-left: 2em; }
        /* -- ending ---------------------------------------------------------------------- */
        #ending {
        }
        #div_base {
                    position:absolute;
                    top:0%;
                    left:5%;
                    right:5%;
                    width: auto;
                    height: auto;
                    margin: -15px 0 0 0;
        }
    </style>
    """
    
        # ------------------------------------------------------------------------
        # Heading
        #
    
        HEADING_TMPL = """
        <div class='page-header'>
            <h1>%(title)s</h1>
        %(parameters)s
        </div>
        <div style="float: left;width:50%%;"><p class='description'>%(description)s</p></div>
        <div id="chart" style="width:50%%;height:400px;float:left;"></div>
    """  # variables: (title, parameters, description)
    
        HEADING_ATTRIBUTE_TMPL = """<p class='attribute'><strong>%(name)s:</strong> %(value)s</p>
    """  # variables: (name, value)
    
        # ------------------------------------------------------------------------
        # Report
        #
    
        REPORT_TMPL = u"""
        <div class="btn-group btn-group-sm">
            <button class="btn btn-default" onclick='javascript:showCase(0)'>总结</button>
            <button class="btn btn-default" onclick='javascript:showCase(1)'>失败</button>
            <button class="btn btn-default" onclick='javascript:showCase(2)'>全部</button>
        </div>
        <p></p>
        <table id='result_table' class="table table-bordered">
            <colgroup>
                <col align='left' />
                <col align='right' />
                <col align='right' />
                <col align='right' />
                <col align='right' />
                <col align='right' />
            </colgroup>
            <tr id='header_row'>
                <td>测试套件/测试用例</td>
                <td>总数</td>
                <td>通过</td>
                <td>失败</td>
                <td>错误</td>
                <td>查看</td>
            </tr>
            %(test_list)s
            <tr id='total_row'>
                <td>总计</td>
                <td>%(count)s</td>
                <td>%(Pass)s</td>
                <td>%(fail)s</td>
                <td>%(error)s</td>
                <td>&nbsp;</td>
            </tr>
        </table>
    """  # variables: (test_list, count, Pass, fail, error)
    
        REPORT_CLASS_TMPL = u"""
        <tr class='%(style)s'>
            <td>%(desc)s</td>
            <td>%(count)s</td>
            <td>%(Pass)s</td>
            <td>%(fail)s</td>
            <td>%(error)s</td>
            <td><a href="javascript:showClassDetail('%(cid)s',%(count)s)">详情</a></td>
        </tr>
    """  # variables: (style, desc, count, Pass, fail, error, cid)
    
        REPORT_TEST_WITH_OUTPUT_TMPL = r"""
    <tr id='%(tid)s' class='%(Class)s'>
        <td class='%(style)s'><div class='testcase'>%(desc)s</div></td>
        <td colspan='5' align='center'>
        <!--css div popup start-->
        <a class="popup_link" onfocus='this.blur();' href="javascript:showTestDetail('div_%(tid)s')" >
            %(status)s</a>
        <div id='div_%(tid)s' class="popup_window">
            <pre>%(script)s</pre>
        </div>
        <!--css div popup end-->
        </td>
    </tr>
    """  # variables: (tid, Class, style, desc, status)
    
        REPORT_TEST_NO_OUTPUT_TMPL = r"""
    <tr id='%(tid)s' class='%(Class)s'>
        <td class='%(style)s'><div class='testcase'>%(desc)s</div></td>
        <td colspan='5' align='center'>%(status)s</td>
    </tr>
    """  # variables: (tid, Class, style, desc, status)
    
        REPORT_TEST_OUTPUT_TMPL = r"""%(id)s: %(output)s"""  # variables: (id, output)
    
        # ------------------------------------------------------------------------
        # ENDING
        #
    
        ENDING_TMPL = """<div id='ending'>&nbsp;</div>"""
    
    
    # -------------------- The end of the Template class -------------------
    
    
    TestResult = unittest.TestResult
    
    
    class _TestResult(TestResult):
        # note: _TestResult is a pure representation of results.
        # It lacks the output and reporting ability compares to unittest._TextTestResult.
    
        def __init__(self, verbosity=1):
            TestResult.__init__(self)
            self.stdout0 = None
            self.stderr0 = None
            self.success_count = 0
            self.failure_count = 0
            self.error_count = 0
            self.verbosity = verbosity
    
            # result is a list of result in 4 tuple
            # (
            #   result code (0: success; 1: fail; 2: error),
            #   TestCase object,
            #   Test output (byte string),
            #   stack trace,
            # )
            self.result = []
            self.subtestlist = []
    
        def startTest(self, test):
            TestResult.startTest(self, test)
            # just one buffer for both stdout and stderr
            self.outputBuffer = io.StringIO()
            stdout_redirector.fp = self.outputBuffer
            stderr_redirector.fp = self.outputBuffer
            self.stdout0 = sys.stdout
            self.stderr0 = sys.stderr
            sys.stdout = stdout_redirector
            sys.stderr = stderr_redirector
    
        def complete_output(self):
            """
            Disconnect output redirection and return buffer.
            Safe to call multiple times.
            """
            if self.stdout0:
                sys.stdout = self.stdout0
                sys.stderr = self.stderr0
                self.stdout0 = None
                self.stderr0 = None
            return self.outputBuffer.getvalue()
    
        def stopTest(self, test):
            # Usually one of addSuccess, addError or addFailure would have been called.
            # But there are some path in unittest that would bypass this.
            # We must disconnect stdout in stopTest(), which is guaranteed to be called.
            self.complete_output()
    
        def addSuccess(self, test):
            if test not in self.subtestlist:
                self.success_count += 1
                TestResult.addSuccess(self, test)
                output = self.complete_output()
                self.result.append((0, test, output, ''))
                if self.verbosity > 1:
                    sys.stderr.write('ok ')
                    sys.stderr.write(str(test))
                    sys.stderr.write('\n')
                else:
                    sys.stderr.write('.')
    
        def addError(self, test, err):
            self.error_count += 1
            TestResult.addError(self, test, err)
            _, _exc_str = self.errors[-1]
            output = self.complete_output()
            self.result.append((2, test, output, _exc_str))
            if self.verbosity > 1:
                sys.stderr.write('E  ')
                sys.stderr.write(str(test))
                sys.stderr.write('\n')
            else:
                sys.stderr.write('E')
    
        def addFailure(self, test, err):
            self.failure_count += 1
            TestResult.addFailure(self, test, err)
            _, _exc_str = self.failures[-1]
            output = self.complete_output()
            self.result.append((1, test, output, _exc_str))
            if self.verbosity > 1:
                sys.stderr.write('F  ')
                sys.stderr.write(str(test))
                sys.stderr.write('\n')
            else:
                sys.stderr.write('F')
    
        def addSubTest(self, test, subtest, err):
            if err is not None:
                if getattr(self, 'failfast', False):
                    self.stop()
                if issubclass(err[0], test.failureException):
                    self.failure_count += 1
                    errors = self.failures
                    errors.append((subtest, self._exc_info_to_string(err, subtest)))
                    output = self.complete_output()
                    self.result.append((1, test, output + '\nSubTestCase Failed:\n' + str(subtest),
                                        self._exc_info_to_string(err, subtest)))
                    if self.verbosity > 1:
                        sys.stderr.write('F  ')
                        sys.stderr.write(str(subtest))
                        sys.stderr.write('\n')
                    else:
                        sys.stderr.write('F')
                else:
                    self.error_count += 1
                    errors = self.errors
                    errors.append((subtest, self._exc_info_to_string(err, subtest)))
                    output = self.complete_output()
                    self.result.append(
                        (2, test, output + '\nSubTestCase Error:\n' + str(subtest), self._exc_info_to_string(err, subtest)))
                    if self.verbosity > 1:
                        sys.stderr.write('E  ')
                        sys.stderr.write(str(subtest))
                        sys.stderr.write('\n')
                    else:
                        sys.stderr.write('E')
                self._mirrorOutput = True
            else:
                self.subtestlist.append(subtest)
                self.subtestlist.append(test)
                self.success_count += 1
                output = self.complete_output()
                self.result.append((0, test, output + '\nSubTestCase Pass:\n' + str(subtest), ''))
                if self.verbosity > 1:
                    sys.stderr.write('ok ')
                    sys.stderr.write(str(subtest))
                    sys.stderr.write('\n')
                else:
                    sys.stderr.write('.')
    
    
    class HTMLTestRunner(Template_mixin):
    
        def __init__(self, stream=sys.stdout, verbosity=1, title=None, description=None):
            self.stream = stream
            self.verbosity = verbosity
            if title is None:
                self.title = self.DEFAULT_TITLE
            else:
                self.title = title
            if description is None:
                self.description = self.DEFAULT_DESCRIPTION
            else:
                self.description = description
    
            self.startTime = datetime.datetime.now()
    
        def run(self, test):
            "Run the given test case or test suite."
            result = _TestResult(self.verbosity)
            test(result)
            self.stopTime = datetime.datetime.now()
            self.generateReport(test, result)
            print('\nTime Elapsed: %s' % (self.stopTime - self.startTime), file=sys.stderr)
            return result
    
        def sortResult(self, result_list):
            # unittest does not seems to run in any particular order.
            # Here at least we want to group them together by class.
            rmap = {}
            classes = []
            for n, t, o, e in result_list:
                cls = t.__class__
                if cls not in rmap:
                    rmap[cls] = []
                    classes.append(cls)
                rmap[cls].append((n, t, o, e))
            r = [(cls, rmap[cls]) for cls in classes]
            return r
    
        def getReportAttributes(self, result):
            """
            Return report attributes as a list of (name, value).
            Override this to add custom attributes.
            """
            startTime = str(self.startTime)[:19]
            duration = str(self.stopTime - self.startTime)
            status = []
            if result.success_count: status.append(u'通过 %s' % result.success_count)
            if result.failure_count: status.append(u'失败 %s' % result.failure_count)
            if result.error_count:   status.append(u'错误 %s' % result.error_count)
            if status:
                status = ' '.join(status)
            else:
                status = 'none'
            return [
                (u'开始时间', startTime),
                (u'运行时长', duration),
                (u'状态', status),
            ]
    
        def generateReport(self, test, result):
            report_attrs = self.getReportAttributes(result)
            generator = 'HTMLTestRunner %s' % __version__
            stylesheet = self._generate_stylesheet()
            heading = self._generate_heading(report_attrs)
            report = self._generate_report(result)
            ending = self._generate_ending()
            chart = self._generate_chart(result)
            output = self.HTML_TMPL % dict(
                title=saxutils.escape(self.title),
                generator=generator,
                stylesheet=stylesheet,
                heading=heading,
                report=report,
                ending=ending,
                chart_script=chart
            )
            self.stream.write(output.encode('utf8'))
    
        def _generate_stylesheet(self):
            return self.STYLESHEET_TMPL
    
        def _generate_heading(self, report_attrs):
            a_lines = []
            for name, value in report_attrs:
                line = self.HEADING_ATTRIBUTE_TMPL % dict(
                    name=saxutils.escape(name),
                    value=saxutils.escape(value),
                )
                a_lines.append(line)
            heading = self.HEADING_TMPL % dict(
                title=saxutils.escape(self.title),
                parameters=''.join(a_lines),
                description=saxutils.escape(self.description),
            )
            return heading
    
        def _generate_report(self, result):
            rows = []
            sortedResult = self.sortResult(result.result)
            for cid, (cls, cls_results) in enumerate(sortedResult):
                # subtotal for a class
                np = nf = ne = 0
                for n, t, o, e in cls_results:
                    if n == 0:
                        np += 1
                    elif n == 1:
                        nf += 1
                    else:
                        ne += 1
    
                # format class description
                if cls.__module__ == "__main__":
                    name = cls.__name__
                else:
                    name = "%s.%s" % (cls.__module__, cls.__name__)
                doc = cls.__doc__ and cls.__doc__.split("\n")[0] or ""
                desc = doc and '%s: %s' % (name, doc) or name
    
                row = self.REPORT_CLASS_TMPL % dict(
                    style=ne > 0 and 'errorClass' or nf > 0 and 'failClass' or 'passClass',
                    desc=desc,
                    count=np + nf + ne,
                    Pass=np,
                    fail=nf,
                    error=ne,
                    cid='c%s' % (cid + 1),
                )
                rows.append(row)
    
                for tid, (n, t, o, e) in enumerate(cls_results):
                    self._generate_report_test(rows, cid, tid, n, t, o, e)
    
            report = self.REPORT_TMPL % dict(
                test_list=''.join(rows),
                count=str(result.success_count + result.failure_count + result.error_count),
                Pass=str(result.success_count),
                fail=str(result.failure_count),
                error=str(result.error_count),
            )
            return report
    
        def _generate_chart(self, result):
            chart = self.ECHARTS_SCRIPT % dict(
                Pass=str(result.success_count),
                fail=str(result.failure_count),
                error=str(result.error_count),
            )
            return chart
    
        def _generate_report_test(self, rows, cid, tid, n, t, o, e):
            # e.g. 'pt1.1', 'ft1.1', etc
            has_output = bool(o or e)
            tid = (n == 0 and 'p' or 'f') + 't%s.%s' % (cid + 1, tid + 1)
            name = t.id().split('.')[-1]
            doc = t.shortDescription() or ""
            desc = doc and ('%s: %s' % (name, doc)) or name
            tmpl = has_output and self.REPORT_TEST_WITH_OUTPUT_TMPL or self.REPORT_TEST_NO_OUTPUT_TMPL
    
            script = self.REPORT_TEST_OUTPUT_TMPL % dict(
                id=tid,
                output=saxutils.escape(o + e),
            )
    
            row = tmpl % dict(
                tid=tid,
                Class=(n == 0 and 'hiddenRow' or 'none'),
                style=(n == 2 and 'errorCase' or (n == 1 and 'failCase' or 'none')),
                desc=desc,
                script=script,
                status=self.STATUS[n],
            )
            rows.append(row)
            if not has_output:
                return
    
        def _generate_ending(self):
            return self.ENDING_TMPL
    
    
    ##############################################################################
    # Facilities for running tests from the command line
    ##############################################################################
    
    # Note: Reuse unittest.TestProgram to launch test. In the future we may
    # build our own launcher to support more specific command line
    # parameters like test title, CSS, etc.
    class TestProgram(unittest.TestProgram):
        """
        A variation of the unittest.TestProgram. Please refer to the base
        class for command line parameters.
        """
    
        def runTests(self):
            # Pick HTMLTestRunner as the default test runner.
            # base class's testRunner parameter is not useful because it means
            # we have to instantiate HTMLTestRunner before we know self.verbosity.
            if self.testRunner is None:
                self.testRunner = HTMLTestRunner(verbosity=self.verbosity)
            unittest.TestProgram.runTests(self)
    
    
    main = TestProgram
    
    ##############################################################################
    # Executing this module from the command line
    ##############################################################################
    
    if __name__ == "__main__":
        main(module=None)
    

    九、Python+unittest+requests+HTMLTestRunner完整的接口自动化测试框架搭建_08——调用生成测试报告

    先别急着创建runAll.py文件(所有工作做完,最后我们运行runAll.py文件来执行接口自动化的测试工作并生成测试报告发送报告到相关人邮箱),但是我们在创建此文件前,还缺少点东东。按我的目录结构创建caselist.txt文件,内容如下:

    user/test01case
    #user/test02case
    #user/test03case
    #user/test04case
    #user/test05case
    #shop/test_shop_list
    #shop/test_my_shop
    #shop/test_new_shop

    这个文件的作用是,我们通过这个文件来控制,执行哪些模块下的哪些unittest用例文件。如在实际的项目中:user模块下的test01case.py,店铺shop模块下的我的店铺my_shop,如果本轮无需执行哪些模块的用例的话,就在前面添加#。我们继续往下走,还缺少一个发送邮件的文件。在common下创建configEmail.py文件,内容如下:

    # import os
    # import win32com.client as win32
    # import datetime
    # import readConfig
    # import getpathInfo
    # 
    # 
    # read_conf = readConfig.ReadConfig()
    # subject = read_conf.get_email('subject')#从配置文件中读取,邮件主题
    # app = str(read_conf.get_email('app'))#从配置文件中读取,邮件类型
    # addressee = read_conf.get_email('addressee')#从配置文件中读取,邮件收件人
    # cc = read_conf.get_email('cc')#从配置文件中读取,邮件抄送人
    # mail_path = os.path.join(getpathInfo.get_Path(), 'result', 'report.html')#获取测试报告路径
    # 
    # class send_email():
    #     def outlook(self):
    #         olook = win32.Dispatch("%s.Application" % app)
    #         mail = olook.CreateItem(win32.constants.olMailItem)
    #         mail.To = addressee # 收件人
    #         mail.CC = cc # 抄送
    #         mail.Subject = str(datetime.datetime.now())[0:19]+'%s' %subject#邮件主题
    #         mail.Attachments.Add(mail_path, 1, 1, "myFile")
    #         content = """
    #                     执行测试中……
    #                     测试已完成!!
    #                     生成报告中……
    #                     报告已生成……
    #                     报告已邮件发送!!
    #                     """
    #         mail.Body = content
    #         mail.Send()
    # 
    # 
    # if __name__ == '__main__':# 运营此文件来验证写的send_email是否正确
    #     print(subject)
    #     send_email().outlook()
    #     print("send email ok!!!!!!!!!!")
    
    
    # 两种方式,第一种是用的win32com,因为系统等各方面原因,反馈win32问题较多,建议改成下面的smtplib方式
    import os
    import smtplib
    import base64
    from email.mime.text import MIMEText
    from email.mime.multipart import MIMEMultipart
    
    
    class SendEmail(object):
        def __init__(self, username, passwd, recv, title, content,
                     file=None, ssl=False,
                     email_host='smtp.163.com', port=25, ssl_port=465):
            self.username = username  # 用户名
            self.passwd = passwd  # 密码
            self.recv = recv  # 收件人,多个要传list ['a@qq.com','b@qq.com]
            self.title = title  # 邮件标题
            self.content = content  # 邮件正文
            self.file = file  # 附件路径,如果不在当前目录下,要写绝对路径
            self.email_host = email_host  # smtp服务器地址
            self.port = port  # 普通端口
            self.ssl = ssl  # 是否安全链接
            self.ssl_port = ssl_port  # 安全链接端口
    
        def send_email(self):
            msg = MIMEMultipart()
            # 发送内容的对象
            if self.file:  # 处理附件的
                file_name = os.path.split(self.file)[-1]  # 只取文件名,不取路径
                try:
                    f = open(self.file, 'rb').read()
                except Exception as e:
                    raise Exception('附件打不开!!!!')
                else:
                    att = MIMEText(f, "base64", "utf-8")
                    att["Content-Type"] = 'application/octet-stream'
                    # base64.b64encode(file_name.encode()).decode()
                    new_file_name = '=?utf-8?b?' + base64.b64encode(file_name.encode()).decode() + '?='
                    # 这里是处理文件名为中文名的,必须这么写
                    att["Content-Disposition"] = 'attachment; filename="%s"' % (new_file_name)
                    msg.attach(att)
            msg.attach(MIMEText(self.content))  # 邮件正文的内容
            msg['Subject'] = self.title  # 邮件主题
            msg['From'] = self.username  # 发送者账号
            msg['To'] = ','.join(self.recv)  # 接收者账号列表
            if self.ssl:
                self.smtp = smtplib.SMTP_SSL(self.email_host, port=self.ssl_port)
            else:
                self.smtp = smtplib.SMTP(self.email_host, port=self.port)
            # 发送邮件服务器的对象
            self.smtp.login(self.username, self.passwd)
            try:
                self.smtp.sendmail(self.username, self.recv, msg.as_string())
                pass
            except Exception as e:
                print('出错了。。', e)
            else:
                print('发送成功!')
            self.smtp.quit()
    
    
    if __name__ == '__main__':
    
        m = SendEmail(
            username='@163.com',
            passwd='',
            recv=[''],
            title='',
            content='测试发送邮件',
            file=r'E:\test_record\v2.3.3\测试截图\调整样式.png',
            ssl=True,
        )
        m.send_email()

    运行configEmail.py验证邮件发送是否正确

    邮件已发送成功,我们进入到邮箱中进行查看,一切OK~~不过这我要说明一下,我写的send_email是调用的outlook,如果您的电脑本地是使用的其他邮件服务器的话,这块的代码需要修改为您想使用的邮箱调用代码

    如果遇到发送的多个收件人,但是只有第一个收件人可以收到邮件,或者收件人为空可以参考http://www.361way.com/smtplib-multiple-addresses/5503.html

    继续往下走,这下我们该创建我们的runAll.py文件了

    import os
    import common.HTMLTestRunner as HTMLTestRunner
    import getpathInfo
    import unittest
    import readConfig
    from common.configEmail import SendEmail
    from apscheduler.schedulers.blocking import BlockingScheduler
    import pythoncom
    # import common.Log
    
    send_mail = SendEmail(
            username='@163.com',
            passwd='',
            recv=[''],
            title='',
            content='测试发送邮件',
            file=r'E:\test_record\v2.3.3\测试截图\调整样式.png',
            ssl=True,
        )
    path = getpathInfo.get_Path()
    report_path = os.path.join(path, 'result')
    on_off = readConfig.ReadConfig().get_email('on_off')
    # log = common.Log.logger
    
    class AllTest:#定义一个类AllTest
        def __init__(self):#初始化一些参数和数据
            global resultPath
            resultPath = os.path.join(report_path, "report.html")#result/report.html
            self.caseListFile = os.path.join(path, "caselist.txt")#配置执行哪些测试文件的配置文件路径
            self.caseFile = os.path.join(path, "testCase")#真正的测试断言文件路径
            self.caseList = []
    
        def set_case_list(self):
            """
            读取caselist.txt文件中的用例名称,并添加到caselist元素组
            :return:
            """
            fb = open(self.caseListFile)
            for value in fb.readlines():
                data = str(value)
                if data != '' and not data.startswith("#"):# 如果data非空且不以#开头
                    self.caseList.append(data.replace("\n", ""))#读取每行数据会将换行转换为\n,去掉每行数据中的\n
            fb.close()
    
        def set_case_suite(self):
            """
    
            :return:
            """
            self.set_case_list()#通过set_case_list()拿到caselist元素组
            test_suite = unittest.TestSuite()
            suite_module = []
            for case in self.caseList:#从caselist元素组中循环取出case
                case_name = case.split("/")[-1]#通过split函数来将aaa/bbb分割字符串,-1取后面,0取前面
                print(case_name+".py")#打印出取出来的名称
                #批量加载用例,第一个参数为用例存放路径,第一个参数为路径文件名
                discover = unittest.defaultTestLoader.discover(self.caseFile, pattern=case_name + '.py', top_level_dir=None)
                suite_module.append(discover)#将discover存入suite_module元素组
                print('suite_module:'+str(suite_module))
            if len(suite_module) > 0:#判断suite_module元素组是否存在元素
                for suite in suite_module:#如果存在,循环取出元素组内容,命名为suite
                    for test_name in suite:#从discover中取出test_name,使用addTest添加到测试集
                        test_suite.addTest(test_name)
            else:
                print('else:')
                return None
            return test_suite#返回测试集
    
        def run(self):
            """
            run test
            :return:
            """
            try:
                suit = self.set_case_suite()#调用set_case_suite获取test_suite
                print('try')
                print(str(suit))
                if suit is not None:#判断test_suite是否为空
                    print('if-suit')
                    fp = open(resultPath, 'wb')#打开result/20181108/report.html测试报告文件,如果不存在就创建
                    #调用HTMLTestRunner
                    runner = HTMLTestRunner.HTMLTestRunner(stream=fp, title='Test Report', description='Test Description')
                    runner.run(suit)
                else:
                    print("Have no case to test.")
            except Exception as ex:
                print(str(ex))
                #log.info(str(ex))
    
            finally:
                print("*********TEST END*********")
                #log.info("*********TEST END*********")
                fp.close()
            #判断邮件发送的开关
            if on_off == 'on':
                send_mail.send_email()
            else:
                print("邮件发送开关配置关闭,请打开开关后可正常自动发送测试报告")
    # pythoncom.CoInitialize()
    # scheduler = BlockingScheduler()
    # scheduler.add_job(AllTest().run, 'cron', day_of_week='1-5', hour=14, minute=59)
    # scheduler.start()
    
    if __name__ == '__main__':
        AllTest().run()
    
    
    

    执行runAll.py,进到邮箱中查看发送的测试结果报告,打开查看

    然后继续,我们框架到这里就算基本搭建好了,但是缺少日志的输出,在一些关键的参数调用的地方我们来输出一些日志。从而更方便的来维护和查找问题。

    按目录结构继续在common下创建Log.py,内容如下:

    import os
    import logging
    from logging.handlers import TimedRotatingFileHandler
    import getpathInfo
    
    path = getpathInfo.get_Path()
    log_path = os.path.join(path, 'result')  # 存放log文件的路径
    
    
    class Logger(object):
        def __init__(self, logger_name='logs…'):
            self.logger = logging.getLogger(logger_name)
            logging.root.setLevel(logging.NOTSET)
            self.log_file_name = 'logs'  # 日志文件的名称
            self.backup_count = 5  # 最多存放日志的数量
            # 日志输出级别
            self.console_output_level = 'WARNING'
            self.file_output_level = 'DEBUG'
            # 日志输出格式
            self.formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    
        def get_logger(self):
            """在logger中添加日志句柄并返回,如果logger已有句柄,则直接返回"""
            if not self.logger.handlers:  # 避免重复日志
                console_handler = logging.StreamHandler()
                console_handler.setFormatter(self.formatter)
                console_handler.setLevel(self.console_output_level)
                self.logger.addHandler(console_handler)
    
                # 每天重新创建一个日志文件,最多保留backup_count份
                file_handler = TimedRotatingFileHandler(filename=os.path.join(log_path, self.log_file_name), when='D',
                                                        interval=1, backupCount=self.backup_count, delay=True,
                                                        encoding='utf-8')
                file_handler.setFormatter(self.formatter)
                file_handler.setLevel(self.file_output_level)
                self.logger.addHandler(file_handler)
            return self.logger
    
    
    logger = Logger().get_logger()

    然后我们在需要我们输出日志的地方添加日志:

    我们修改runAll.py文件,在顶部增加import common.Log,然后增加标红框的代码

    让我们再来运行一下runAll.py文件,发现在result下多了一个logs文件,我们打开看一下有没有我们打印的日志

    OK,至此我们的接口自动化测试的框架就搭建完了,后续我们可以将此框架进行进一步优化改造,使用我们真实项目的接口,结合持续集成定时任务等,让这个项目每天定时的来跑啦~~~

    欢迎添加我的微信,相互学习探讨~1305618688,qq交流群:849102042

    2020年9月23追加

    一、、最近有太多人反馈,执行通过后report.html文件中内容为空,这个基本上多数原因是因为用例执行异常报错,导致没有成功执行用例,所以没有生成数据。大家可以运行testCase下的test01Case.py等用例文件,看是不是运行报错了。如果运行成功,再去执行runAll试一下

    展开全文
  • 每一个测试人员都应该了解每种框架的优缺点,以帮助你的团队更好地确定最适合的测试框架,以达到事半功倍。

    每一个测试人员都应该了解每种框架的优缺点,以帮助你的团队更好地确定最适合的测试的框架,以达到事半功倍。

    什么是测试自动化框架?

    自动化测试框架就是用于测试自动化的框架。具体来说,它提供了自动化测试用例编写、自动化测试用例执行、自动化测试报告生成等基础功能。我们只需要基于这个框架,完成和业务高度相关的测试用例设计和实现即可。另外,框架会为我们处理好复杂度与扩展性的问题,我们无需为此操心。

    测试自动化框架是在创建和设计测试用例时使用的一组最佳实践或准则。
    测试准则集可以包括编码标准,对象存储库,测试数据处理方法,有关外部存储访问的信息等。

    这些准则并非强制,但是在自动化脚本过程中,它们提高了测试的效率并产生了有益的结果。

    使用测试自动化框架的好处

    • 更全的测试范围
    • 降低脚本维护成本
    • 节省人力成本
    • 提高测试速度和效率
    • 可重用的测试代码
    • 易于报告

    根据需求使用适配的自动化测试框架有助于加快测试过程,并消除人为错误。它还使测试维护更加容易,加快测试进度,节省成本、时间和精力。此外,框架QA团队能够充分开发、执行和报告测试过程,同时还使代码可在多种情况下重用。

    5种最流行的自动化测试框架类型

    团队根据团队规模、经验水平、用户需求等因素来选择测试框架。以下是五种最流行的框架及其优缺点:

    1、线性框架
    这是最基本的框架类型。它通常被称为“记录和回放(record and playback)”框架。

    在这个过程中,测试代码的创建和执行是按线性或顺序编写的——测试人员手动记录每一个步骤,并自动回放记录的脚本。这些步骤包括导航、用户输入和检查点。它最适合小型应用程序或团队。
    在此过程中,测试代码的创建和执行以线性或顺序方式编写-测试人员手动记录每个步骤并自动播放记录的脚本。这些步骤包括导航,用户输入和检查点。最适合小型应用程序或小团队。

    优点:
    线性框架最大的好处是生成测试用例的速度快,直接录制;无须代码基础,无须手动编写测试代码,因此门槛较低、易于上手。

    缺点:
    然而线性框架的不足之处也很明显:录制的脚本是固定的(hardcode),不可重用。这意味着,当应用发生微小变化时,上一次录制的脚本可能就无法使用了,需要重新录制(rework),从而产生大量的后期维护成本。

    2、基于模块化的框架
    顾名思义,此框架允许将被测应用程序划分为单独的模块,单元或部分。每个模块都会为它们创建独立的测试脚本。因此,每个模块及其测试脚本的组合可以构建代表各种测试案例的更大的测试。

    优点:
    该框架在创建模块时使用抽象。因此,应用程序更改将只影响与它们相关联的测试脚本所涉及的模块,而不影响其他部分。
    高度的模块化,这使得维护更加容易且具有成本效益
    创建测试用例所需的精力最少,因为可以重复使用不同模块的测试脚本。

    缺点:
    如果没有语言开发基础,则建立框架可能会很困难。
    由于将数据硬编码到测试脚本中,因此无法重复使用数据集——因为测试是单独执行的。

    3、库结构框架
    该库体系结构框架建立在模块化框架的基础上,但具有其他好处。这样做的好处是,它不仅可以将被测应用程序划分为测试脚本,还可以将测试脚本中的相似任务划分为通用功能。

    然后创建一个库,该库构成了AUT的常用功能,可以在需要时由测试脚本调用。

    优点:
    高度的模块化,这使得测试维护简单且预算友好。
    它具有高度的可重用性,因为它的公共函数库可以被几个测试脚本使用。
    缺点:
    框架中引入的库使其更加复杂。
    测试数据也被硬编码到测试脚本中。因此,数据中的更改必须适用于测试脚本。
    测试脚本的开发需要更多的时间和技术。

    4、数据驱动框架
    在数据驱动框架中,测试数据和测试脚本是分离的。在许多测试场景中,需要使用不同的测试数据多次测试同一功能或特性。如果测试数据是hardcode进测试脚本的,那么每更换一次测试数据都需要修改测试脚本。这是很大的工作量。此时,可以使用数据驱动框架。具体来说,测试脚本是固定的,而测试数据可以从外部的数据文件,以Excel、CSV、SQL等形式作为参数传入测试脚本。这样,我们只需要维护一份脚本和一份数据文件即可。
    优点:
    总体来说,这种框架最大的好处就是易于维护。
    测试脚本中的任何更改都不会影响测试数据。因此,可以避免对数据进行硬编码。
    可以使用多组数据进行测试。
    可以通过更改外部数据库中的测试数据来测试各种测试方案,从而减少所需的测试脚本数量。
    缺点:
    准备和计划框架的通用测试脚本,识别与格式化测试数据需要花费时间。
    框架设计的使用需要经验丰富的测试人员,因为它的复杂性,需要具备多种编程语言知识。

    5、关键字驱动框架
    该框架是数据驱动框架的扩展。测试数据和测试脚本也被分离,不同的是,该框架要更进一步地将测试脚本中的通用功能剥离出来,形成关键词(keyword)。测试脚本本质上就是对一系列通用的或者自定义的关键词的调用。这样做的好处是关键词可以在多个测试中复用,并且测试脚本更加易于维护。不过,实现这样一个框架并非易事。
    优点:
    与数据驱动不同,运行此框架不需要脚本知识。
    可以独立于被测应用程序构建测试脚本。
    一个关键字可以在多个测试脚本中使用。因此该代码是可重用的。
    缺点:
    设计框架和维护关键字对自动化的专业知识要求比较高。
    实现该框架的成本相对较高,而且设置起来也比较耗时和复杂。

    综上所述,实现用于自动化测试的框架需要选择一种灵活的工具。该工具应支持广泛的应用程序,并满足测试要求。另外,应该有正确的策略来定义应该自动化哪些部分。

    需要指出的是,业界已经有了实现上述各种测试自动化框架的工具。通常来说,我们并不需要重新发明一个新的框架,而是基于已有的框架去进行优化升级,使之适合自己的项目需求,来完成自动化测试工作。
    那么,面对一个新的自动化测试框架,如何着手工作呢?
    我们应该聚焦在以下四个问题上。

    1、如何生成测试用例?
    不同的框架,生成测试用例的方法不一样。
    对于线性框架来说,无须编写脚本,只需要点击预设的按钮就能够生成测试用例;比如Katalon,直接录制生成测试用例。
    对于多数框架来说,生成测试用例需要编程。当然,不同框架使用的编程语言、编程风格有差异。
    对于Selenium框架来说,使用的是通用编程语言Java和Python,可能更多的是对Selenium进行二次封装,以便更好更快的生成用例;
    对于Robot Framework来说,使用的是其专用的Robot Framework编程语言。
    一般来说,使用框架编程的过程很多时候就是调用库接口的过程。因此作为前提,在编写用例之前,我们需要熟悉框架提供的库的种类和功能,以及这些库所提供的API的使用方法。

    2、如何执行测试用例?
    当测试用例完成之后,我们需要运行测试用例。
    自动化测试是通过GUI图形界面来触发,还是通过CLI命令触发,这因框架而异。
    当然,仅仅知道如何触发测试是不够的。我们通常有更多的需求。
    例如,如何选择性地执行满足特定条件的测试用例子集?
    如何设置全局的执行参数(超时时间、日志路径、报告形式等)?
    如何动态地给测试用例集传入参数?

    一般来说,一个完整的框架需要提供足够多的控制选项,从而让我们根据需求定制执行测试的方式。
    以Robot Framework为例,其执行用例的命令具有30多个不同的选项。
    这提供了足够的自由度和一些非常棒的功能。例如其dryrun选项,可以让我们在不实际执行用例的情况下,快速检查出测试用例中参数不匹配、语法不正确、关键词找不到、库导入失败等错误,非常实用。

    3、如何检查测试结果?
    测试执行结束之后,我们需要关注测试结果。不同的框架会以不同形式提供测试结果。例如,测试结果既能以控制台日志的形式体现、也能够以图表和报告的形式体现,并以邮件发送或者展示在网站上。
    根据测试结果,我们可以很容易地了解测试的执行情况,包括测试的成功/失败情况、测试的整体/局部用时等。
    当测试失败时,我们尤其需要关注测试失败的具体情况。
    通常,我们关心失败是由于我们使用框架的方法不当造成的,还是由于被测软件的质量问题。这一点,只能通过检查和分析测试结果得到。

    4、如何扩展测试框架?
    一般来说,框架只是提供了最基本的功能。很多时候,框架并不能直接满足自动化测试的需求。这时我们可以寻求第三方的、与框架本身兼容的库或者插件。如果第三方工具不能满足我们的需求,我们就需要开发自己的库和工具。
    例如,对于HTTP、SSH等公有协议,我们很容易在网络上找到某个框架的第三方库;
    而对于只用于公司产品的私有协议,我们通常无法找到第三方库,只能自己开发。
    自己开发时,需要注意的是要遵从框架的规范,使得开发出的库能够与框架无缝兼容。

    说在最后,选择了一个框架,在享受其好处时,也不得不承受其不足。
    如果我们的关键需求受制于框架,并且框架也不容易扩展,那么我们就可能需要开发自己的框架。这是一件投入较大的事情。在大多数情况下,还是建议重用和有限扩展已有的框架。毕竟,不要重新发明轮子——Don’t reinvent the wheel!

    展开全文
  • 接口自动化测试框架搭建

    千次阅读 2021-03-29 19:15:09
    测试用例管理使用了testNg管理,使用了TestNG参数化测试,通过xml文件来执行case。 测试报告这里用到第三方的包ReportNG 项目组织用Maven 二、准备 使用工具:eclipse,maven 用到的第三方jar包:dom4j、reportng...
  • 几种典型的软件自动化测试框架

    千次阅读 2020-09-22 15:30:24
    一个自动化测试框架就是一个由假设、概念以及为自动化测试提供支持的实践的集合。以下描述五种基本的自动测试框架:模块化测试脚本框架,测试库构架框架,关键字驱动/表驱动测试框架,数据驱动测试框架,以及混合...
  • 基于python的接口自动化测试框架(带演示案例版),可拓展,可添加UI自动化功能等等。
  • 2019 Python接口自动化测试框架实战开发(一)

    万次阅读 多人点赞 2019-06-28 15:55:25
    说明:该篇博客是博主一字一码编写的,实属不易,请尊重原创,谢谢大家!...整个项目分为四个部分:接口基础丶接口开发丶Unittest与接口测试结合以及接口自动化框架从设计到开发 接口基础包括:H...
  • 3分钟教你搭建自动化测试框架

    千次阅读 多人点赞 2018-12-24 14:35:06
    Selenium 是一个基于浏览器的自动化工具,它提供了一种跨平台、跨浏览器的端到端的web自动化解决方案。Selenium主要包括三部分:Selenium IDE、Selenium WebDriver 和Selenium Grid: Selenium IDE:Firefox的一个...
  • Test Runner(测试运行器)是测试框架的重要组成部分,他用于组装待运行的测试用例及其配置,然后按照指定的要求运行这些测试用例,并将测试结果写入控制台或日志文件
  • 自动化测试框架unittest自动化测试框架unittest自动化测试框架unittest
  • python pytest selenium 自动化测试框架搭建

    千次阅读 多人点赞 2020-07-01 15:39:46
    python pytest selenium 自动化测试框架搭建 公司一直有这个自动化测试需求,前期利用c++或者python进行了一些自动化脚本的编写。这几天没有版本更迭,基于前期的工作,把自动化测试整理了一部分功能模块。现在的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 411,491
精华内容 164,596
关键字:

自动化测试框架