精华内容
下载资源
问答
  • 持续集成测试工具与实践案例分
  • Jenkins持续集成测试

    2016-01-26 16:20:36
    Jenkins持续集成测试说明文档。适用于持续集成环境配置。敏捷开发必备工具
  • 提起持续集成测试,大家能够想到很多强大的持续集成工具Jenkins、TravisCI等等,然而作为iOS应用开发和测试,绝对不能忽略简单好用的Xcodeserver。run起来! 提起持续集成测试,大家能够想到很多强大的持续集成工具...
  • 关于Jenkins Jenkins是被广泛应用的持续集成、自动化测试、持续部署的框架,甚至有些项目组顺便将其用来做流程管理的工具。根据任务的多寡,Jenkins通常有两种典型的部署方式。 单节点(Master)部署 这种部署...
  • 持续集成的核心价值在于: 1、持续集成中的任何一个环节都是自动完成的,无需太多的人工干预,有利于减少重复过程以节省时间、 费用和 工作量; 2、持续集成保障了每个时间点上团队成员提交的代码是能成功集成的。换...

    持续集成的核心价值在于:
    1、持续集成(CI)中的任何一个环节都是自动完成的,无需太多的人工干预,有利于减少重复过程以节省时间、 费用和 工作量;
    2、持续集成保障了每个时间点上团队成员提交的代码是能成功集成的。换言之,任何时间点都能第一时间 发现软 件的集成问题,使任意时间发布可部署的软件成为了可能;
    3、持续集成还能利于软件本身的发展趋势,这点在需求不明确或是频繁性变更的情景中尤其重要,持续集成的质量能帮助团队进行有效决策,同时建立团队对开发产品的信心。

    jenkins特点

    jenkins是基于java语言开发的测试工具,但它不仅限于构建基于Java的软件
    基于Web访问,用户界面非常友好、直观和灵活 ;提供测试报表功能;拥有大量的插件。

    jenkins的使用

    典型的工作流:

    1. pull
    2. 编译
    3. 测试
    4. 发布
      在这里插入图片描述
      Jenkins会定时获取最新的代码,自动运行你的编译脚本,编译成功后,再运行你的测试脚本,这一步成功后,接 着它会帮你把新程序发布出去,编译失败就会发出通知

    jenkins应用

    将代码从指定路径拉下来,轮询构建,编译成功后发布到指定服务器上
    jenkins使用流程:

    1. 新建任务–输入任务名称–构建自由风格的项目–确定

    2. 描述–配置丢弃构建(10 30)

    3. 源码管理git–把源码路径粘贴,选择分支

    4. 构建触发器:轮询SCM(与定时构建的区别:轮询会智能一些,代码有变动了才会重新构建)–日程表需要用专门的语法输入,例如H 5 * * *,表示每晚5点开始运行Job

    5. 构建–选择执行shell(windows下选择windows构建)—命令:

    $sudo cd /var/lib/jenkins/workspace(进入jenkins指定目录)
    $sudo python TEST.py(项目文件名)
    $sudo scp /var/lib/jenkins/workspace/TEST.py /home/testwork(在同一台服务器中拷贝文件,scp是跨服务器部署,cp是同一台服务器上部署,这里是模拟在不同的服务器上构建)

    1. 配置完成,保存

    将代码从指定路径拉下来,轮询构建,编译测试成功后发布到指定服务器上

    1. 新建任务–输入任务名称–构建自由风格的项目–确定

    2. 描述–配置丢弃构建(10 30)

    3. 源码管理git–把源码路径粘贴,选择分支

    4. 构建触发器:轮询SCM(与定时构建的区别:轮询会智能一些,代码有变动了才会重新构建)–日程表需要用专门的语法输入,例如H 5 * * *,表示每晚5点开始运行Job

    5. 构建–选择执行shell(windows下选择windows构建)—命令:

    $sudo cd /var/lib/jenkins/workspace(进入jenkins指定工作目录)
    $sudo g++ Test.cpp -o compress(编译c++文件)
    $sudo ./compress(执行编译好的文件)
    $sudo scp -r /var/lib/jenkins/workspace/TEST.py /home/testwork(在同一台服务器中拷贝目录)

    ----增加构建步骤
    :编写测试脚本

    #codig utf-8(指定字符集)
    import os(导入模块)
    file1='/var/lib/jenkins/workspace/Input.txt.huffman'
    file2='/var/lib/jenkins/workspace/Input.txt.unhuffman'
    if os.path.exists(file1) and os.path.exists(file2)
      print 'compress success'
    else
      print 'compress fail'
    
    1. 配置完成,保存

    基于MongoDB的分布式图片文件服务器

    1. 安装maven,Deploy war/ear to a containers插件

    2. 新建任务–输入任务名称–构建自由风格的项目–确定

    3. 描述–配置丢弃构建(10 30)

    4. 源码管理git–把源码路径粘贴,选择分支

    5. 构建触发器:轮询SCM(与定时构建的区别:轮询会智能一些,代码有变动了才会重新构建)–日程表需要用专门的语法输入,例如H 5 * * *,表示每晚5点开始运行Job

    6. 构建–选择Execute SonarQube Scanner—命令:

    sonar.projectKey=javaSonar 
    sonar.projectName=JAVAfile sonar.projectVersion=1.0 
    sonar.language=java 
    sonar.sources=/var/lib/jenkins/workspace/javaproject1 
    sonar.sourceEncoding=UTF-8
    

    -----增加构建步骤,选择maven目标,配置maven版本:maven;目标:clean compile findbugs:findbugs install -e ;属性:maven.test.skip=true
    —增加构建后操作:配置AR/EAR files: target/javatest.war(相对于项目我们的路径);add container::增加容器,一般选tomcat 8X就可以;add:添加tomcat的用户名(tomcat)和密码(tomcat)

    这里的username与password需要到tomcat的conf文件夹 中的tomcat-users.xml修改

    <role rolename="tomcat"/> 
    <role rolename="role1"/> 
    <role rolename="manager-gui"/> 
    <role rolename="manager-script"/>
     <role rolename="manager-status"/> 
     <user username="tomcat" password="tomcat" roles="tomcat"/>
      <user username="both" password="tomcat" roles="tomcat,role1"/> 
      <user username="role1" password="tomcat" roles="role1"/>
       <user username="tomcat" password="tomcat" roles="manager-gui,manager-script,manager-status"/
    
    1. 保存
    2. 进行构建
    3. 查看日志

    视图管理

    新建视图–输入视图名称–列表视图–选择要看的视图

    用户管理

    系统管理–管理用户—新建用户—分配权限

    展开全文
  • 微服务架构下的自动化测试持续集成工具
  • 软件测试持续集成

    2021-01-27 11:06:27
    针对这种情况,持续集成工具jenkins被引入到测试工作中,协助测试人员进行“自动化部署、启动”。Jenkins,基于Java开发的一种持续集成工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续...
  • testci 测试持续集成 Install $ spm install testci --save Usage var testci = require('testci'); // use testci
  • 本文来自于网络,文章主要介绍了微服务架构下解决自动化测试、开发联调、测试环境、持续集成方面遇到的问题及解决方案等。在2008年时,市场软件形式大多为CS架构。当时存在的问题在于,开发耗时1-2年且内部的解耦度...
  • 为您提供Hudson 持续集成工具下载,Eclipse Hudson是用Java编写的持续集成(CI)工具,它在servlet容器(例如Apache Tomcat或GlassFish应用服务器)中运行。它支持SCM工具,包括CVS,Subversion,Git和Clearcase,并...
  • 5种优化持续集成测试的方法

    千次阅读 2019-03-24 23:26:49
    1. Create tiny but valuable test suites创建小而有价值的测试套件 2. Refactor the test setup重构测试设置 3. Be smart with your wait times 等待时间要聪明设置 4. Trigger tests automatically 自动化触发...

    目录

    原链接

    翻译内容

    1. Create tiny but valuable test suites 创建小而有价值的测试套件

    2. Refactor the test setup 重构测试设置

    3. Be smart with your wait times 等待时间要聪明设置

    4. Trigger tests automatically 自动化触发测试

    5. Run tests in parallel 并发执行测试

    关于作者

    John Ruberto


    原链接

    https://www.stickyminds.com/article/5-ways-optimize-tests-continuous-integration

    翻译内容

    “Test early, test often.” If you’ve worked with me, you are probably sick of hearing me say that. But it’s common sense that if your tests find a problem shortly after that problem was created, it will be easier to fix. This is one of the principles that makes continuous integration a very powerful strategy.

    “早点测试,经常测试。”如果你和我一起工作过,你可能会因为听到我这么说而感到厌倦。 但常识是,如果您的测试在问题出现后不久,便能发现问题,那么修复起来会更容易。 这是使持续集成成为一种非常强大的策略的原则之一。

    Many times I’ve seen teams that have many automated tests but are not using those tests as part of a continuous integration program. There are often several reasons why the team thinks it cannot use these tests with continuous integration. Maybe the tests take too long to execute, or they are not reliable enough to give accurate results themselves and it will take humans to interpret the results.

    很多时候,我见过团队有很多自动化测试,但没有将这些测试作为持续集成计划的一部分。 团队认为不能在持续集成中使用这些测试通常有几个原因。 也许测试执行时间太长,或者它们不够可靠来给出准确的结果,并且需要人类来解释测试结果。

    When assessing these suites, I start with a simple exercise. First, I draw two axes on a white board. The vertical axis shows the value of the tests and the horizontal axis shows the time it takes the suite to execute.

    在评估这些测试套件时,我先从一个简单的练习开始。 首先,我在白板上画两个轴。 纵轴表示测试的值,横轴表示套件执行的时间。

    The team and I then write down the name of each test suite on a sticky note and place them on the appropriate place on the board. The chart below shows an example of a grid, showing how each test suite measures.

    然后我和团队在便利贴上写下每个测试套件的名称,并将它们放在板上的适当位置。 下图显示了一个网格示例,显示了每个测试套件的测量方式。

    Grid that shows the relationship between time to execute test suites and the value those test suites provide the team

    When we talk about the value of the tests, it’s based on the team’s subjective opinion, so we keep the choices pretty simple: No Value, Moderate Value, High Value, and Very High Value. We base this opinion on the reliability of the tests, or the tests’ ability to give accurate results each time they are executed, and the level of confidence the tests give the team for the quality of the system.

    当我们谈论测试的价值时,它基于团队的主观意见,因此我们的选择非常简单:没有价值,中等价值,高价值和非常高价值。 我们将这种观点建立在测试的可靠性或测试每次执行时给出准确结果的能力,以及测试给团队提供系统质量的信心水平

    For example, some test suites are a must-have when it comes to making a decision, but the results are a little flaky, and when they fail sometimes for no apparent reason, a person has to re-execute those failing tests manually. We might still call this test suite High Value, but if it ran accurately every time, we would call it Very High Value.

    例如,一些测试套件在做出决定时是必须的,但结果有点不稳定,有时当它们因为没有明显原因而失败时,一个人必须手动重新执行那些失败的测试。 我们可能仍然称这个测试套件为High Value,但如果它每次都准确运行,我们称之为非常高的价值。

    On the other side of the coin, sometimes there is a test suite that gets executed because it’s part of a checklist, but no one really knows what the results mean. Maybe the original author has left the team and no one picked up the ownership of that suite. We would put that suite in the No Value category.

    另一方面,有时会有一个测试套件被执行,因为它是清单的一部分,但没有人真正知道结果意味着什么。 也许原作者离开了团队,没有人获得该套件的所有权。 我们会将该套件放在No Value类别中。

    The horizontal axis is easier to determine: It’s simply the number of minutes that it takes to execute that suite.

    横轴更容易确定:它只是执行该套件所需的分钟数。

    Now that you have an assessment of each suite, it’s time to think about improving your suites by making them more valuable (moving up in the diagram) or by helping them execute faster (moving to the left).

    现在您已经对每个套件进行了评估,现在是时候考虑通过使它们更有价值(在图中向上移动)或帮助它们更快地执行(向左移动)来改进套件了。

    For continuous integration, I like to target the tests into four categories: 对于持续集成,我喜欢将测试分为四类:

    • 在十分钟或更短时间内,执行具有极高值的测试
      这些测试可以在每次构建时运行。 这些用于接受构建以进行进一步测试; 在这些测试通过之前,团队都应该考虑构建失败情况。 您的开发人员不希望等待超过十分钟才能获得构建结果。
    • Tests with High Value or better that execute in an hour or less 在一小时或更短时间内,执行具有高价值或更高价格的测试
      These tests can run continuously. For example, you might configure these tests to execute every hour and start again as soon as they are complete. If there isn’t a new build ready yet, you can wait until the next build completes.这些测试可以持续运行。 例如,您可以将这些测试配置为每小时执行一次,并在完成后立即重新开始。 如果尚未准备好新构建,则可以等到下一个构建完成。
    • Tests with High Value or better that take longer than an hour to execute超过一小时时,执行具有高价值或更高价值的测试
      These tests can run daily—or, usually, nightly, so that the results are available when the working day begins for your team.这些测试可以每天运行 - 或者通常每晚运行一次,以便您的团队在工作日时获得结果
    • Tests with Moderate Value 具有中等价值的测试
      These tests can run once per week or once per release cycle. 这些测试可以每周运行一次或每个发布周期运行一次。

    Notice that I did not include tests with No Value. These should be improved to add value, or just dropped from your execution. It doesn’t make sense to keep test suites that don’t add value.

    请注意,我没有包含No Value的测试。 这些应该被改进以增加价值,或者只是从执行中删除。 留着不增加价值的测试套件是没有意义的。

    I chose the time boundaries of ten minutes and one hour based on input from the development teams. They want to get quick feedback. You can imagine a developer waiting for the build results to complete successfully before going to lunch. Your timelines may vary based on your realities; this is just a framework to show the thought process behind selecting the tests that run with the build versus hourly.

    我根据开发团队的意见选择了10分钟和1小时的时间边界。 他们希望获得快速反馈。 您可以想象一个开发人员等待构建结果在午餐前成功完成。 您的时间表可能因您的实际情况而异; 这只是一个框架,用于显示选择使用构建与每小时运行的测试背后的思考过程。

    A huge benefit for executing the tests this frequently is that you are likely to have very few code changes between a successful test run and a failed test run, making it easier to isolate the change that caused the test to fail.

    经常执行测试的一个巨大好处是,您可能在成功的测试运行和失败的测试运行之间进行很少的代码更改,从而更容易隔离导致测试失败的更改。

    There are several strategies that have been useful for optimizing existing tests for the continuous integration suites. Here are five proven practices.

    有几种策略可用于优化持续集成套件的现有测试。 以下是五种经过验证的做法

    1. Create tiny but valuable test suites 创建小而有价值的测试套件

    Choose the most important tests and pull them into a smaller suite that runs faster. These are usually very gross-level tests, but they’re necessary to qualify your system or app for further testing. If these tests don’t pass, it doesn’t make sense to proceed.

    选择最重要的测试并将它们拉入一个运行速度更快的小套件中。 这些通常是非常粗略的测试,但它们是使您的系统或应用程序有资格进行进一步测试所必需的。 如果这些测试没有通过,那么继续进行是没有意义的。

    A good starting point would be to create a new entity and perform the most important operation on that entity. For example, if it’s a note-taking app, the test would be to create a note, add text, close the app, then reopen and verify that the text was saved. If your note-taking app can’t save a note, there isn’t much use in proceeding to other tests.

    一个好的起点是创建一个新实体并对该实体执行最重要的操作。 例如,如果它是一个笔记记录应用程序,测试将是创建一个笔记,添加文本,关闭应用程序,然后重新打开并验证文本已保存。 如果您的笔记记录应用程序无法保存笔记,则进行其他测试没有太大用处。

    We often call these build acceptance tests or build verification tests. If you already have these suites, great; just make sure they execute quickly.

    我们经常称这些为构建验收测试或构建验证测试。 如果你已经拥有这些套件,那就太好了; 只是确保他们快速执行。

    2. Refactor the test setup 重构测试设置

    Tests generally have a setup, then perform verification. For the note-taking example, to verify that the app opens with the previous text present, you first have to set up the test with the text. Examine how your tests are doing the test setup and see if there is a better way.

    测试通常具有设置,然后执行验证。 对于笔记记录示例,要确认应用程序打开时是否存在上一个文本,您首先必须使用文本设置测试。 检查你的测试是如何测试设置的,看看是否有更好的方法。

    For example, one team had a suite of UI-driven tests that took a long time to execute and had many false failures due to timing issues and minor UI tweaks. We refactored that suite to perform the test setup via API commands and do the verification through the UI. This updated suite had the same functional coverage, but it executed 70 percent faster and had about half the false failures caused by UI changes.

    例如,一个团队有一套UI驱动的测试需要花费很长时间才能执行,并且由于时序问题和微小的UI调整而导致许多错误的失败。 我们重构了该套件,通过API命令执行测试设置,并通过UI进行验证。 这个更新的套件具有相同的功能覆盖范围,但它的执行速度提高了70%,并且大约有一半因UI更改而导致的错误故障。

    3. Be smart with your wait times 等待时间要聪明设置

    We have all done it: A flaky test keeps failing because the back end didn’t respond in time or some resource is still loading, so we put a sleep statement in. We intended that to be a temporary workaround, but that was a year ago now.

    我们都已经完成了它:一个不稳定测试不断失败,因为后端没有及时响应或某些资源仍在加载,所以我们把睡眠语句考虑进来了。我们打算这是一个临时的解决方法,但那是一年以前。

    Look for those dreaded sleep statements and see if you can replace them with a smarter wait statement that completes when the event happens, instead of a set period of time.

    查找那些可怕的睡眠语句,看看是否可以用更智能的等待语句替换它们,该等语句在事件发生时完成,而不是设定的一段时间。

    4. Trigger tests automatically 自动化触发测试

    You may have several test suites that are normally initiated by a person during the test phase of a project. Often, it only takes a little shell scripting to be able to include these tests in the continuous integration suite.

    您可能有几个测试套件,通常由一个人在项目的测试阶段启动。 通常,只需要一些shell脚本就可以将这些测试包含在持续集成套件中。

    Security and performance tests are two examples of types of tests that might be performed by a specialist who is not part of the standard test team, so those tests might not be configured for automatic execution. The other benefit of running these tests frequently is that the problems that are found are frequently difficult to fix, so if the problem is identified sooner, the team has more time to fix it. These tests are often classified as Very Valuable, but they take more than an hour to execute, so they are typically executed daily.

    安全性和性能测试是可能由不属于标准测试团队的专家执行的测试类型的两个示例,因此这些测试可能未配置为自动执行。 经常运行这些测试的另一个好处是发现的问题通常很难修复,因此如果问题得到更早发现,团队就有更多时间来解决它。 这些测试通常被归类为非常有价值,但它们需要一个多小时才能执行,因此它们通常每天执行。

    5. Run tests in parallel 并发执行测试

    Virtual machines and cloud computing services coupled with tools that help automatically set up environments and deploy your code make it much more affordable to run tests in parallel. Examine the test suites that take some time to execute and look for opportunities to run those tests in parallel.

    虚拟机和云计算服务以及有助于自动设置环境和部署代码的工具,使得并行运行测试的成本更低。 检查需要一些时间执行的测试套件,并寻找并行运行这些测试的机会。

    On one team, we had a very vital test suite that contained five hundred test cases. This suite took several hours to run, so we didn’t execute it very often. It was a very broad-based test, touching many different features. We were able to break that suite up into about a dozen different suites that could run in parallel, so we could run the tests more frequently (nightly instead of weekly), and we could tell more quickly where any problems lay because the new suites were organized by feature.

    在一个团队中,我们有一个非常重要的测试套件,包含500个测试用例。 这个套件需要几个小时才能运行,所以我们没有经常执行它。 这是一个非常广泛的测试,涉及许多不同的功能。 我们能够将该套件分成几十个可以并行运行的不同套件,因此我们可以更频繁地运行测试(每晚而不是每周),我们可以更快地告诉我们问题所在,因为新的套件是 按功能组织。

    Improving the value of your test suites and the time it takes to execute them can help you optimize your existing test suites to fit into a continuous integration program.

    提高测试套件的价值以及执行测试套件所需的时间可以帮助您优化现有的测试套件,以适应持续集成计划。

    关于作者

    John Ruberto

    John Ruberto采用工程方法将质量建设成软件。 他在Software Leadership Academy,在他的博客和会议发言中,教授应用于质量的领导原则。

    John目前正在咨询质量工程实践和辅导工程师,以成为更好的领导者。 他曾担任First Data,Concur,Intuit,Alcatel,PhoenixBIOS和Boeing的质量工程副总裁。 他拥有Purdue的BSEE,华盛顿的MSCS和SJSU的MBA。 您可以在@JohnRuberto或blog.ruberto.com找到John。

    展开全文
  • 在上次发表的博客中,运行测试作为build的一部分,我展示了VisualStudioCodedUITests怎样集成到产品中去验证它的质量。因为之前没有提及,有一些在SharePoint版本中运行的单元测试的注意事项还是值得一提的;当然,...
  • 如何搭建jenkins持续集成测试环境

    万次阅读 2016-03-26 18:30:04
    Jenkins 是基于 Java 开发的一种持续集成工具,所以,Jenkins 需要 Java 环境。 1.配置java环境 1)下载Java,选择系统所需要的版本。 http://www.java.com/zh_CN/download/manual.jsp 2)安装Java() 3)...

    Jenkins 是基于 Java 开发的一种持续集成工具,所以,Jenkins 需要 Java 环境。
    1.配置java环境
    1)下载Java,选择系统所需要的版本。
    http://www.java.com/zh_CN/download/manual.jsp
    这里写图片描述
    2)安装Java
    3)设置环境变量
    “我的电脑”右键菜单–>属性–>高级–>环境变量–>系统变量->新建
    变量名:JAVA_HOME
    变量值:C:\Program Files\Java\jdk1.8.0_32
    变量名:CLASS_PATH
    变量值:.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
    找到 path 变量名—>“编辑”添加:
    变量名:PATH
    变量值:%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
    在 Windows 命令提示符下验证 java 是否成功
    C:\Users####>java
    用法: java [-options] class [args…]


    2.配置Tomcat环境
    tomcat 是真对 Java 的一个开源中间件服务器(容器),基于 Java Web 的项目需要借助 tomcat 才能运行起来。
    1)下载Tomcat选择合适的版本
    Tomcat官方网站: http://tomcat.apache.org/
    这里写图片描述
    2)解压此文件,对下载的压缩包进行解压,目录结构如下:
    这里写图片描述
    通常将需要运行有应用放到 webapps/目录下,进入 bin/目录下,双击 startup.bat 来启动 tomcat 服务器。
    3.配置Jenkins环境
    1)下载Jenkins
    官方网站:http://jenkins-ci.org/
    2)安装Jenkins
    这里写图片描述
    next—>
    我们直接将其安装到 tomcat 的 webapps\目录下。
    D:\apache-tomcat-8.0.32\webapps\jenkins
    3)运行Jenkins
    进行 tomcat 的 bin/目录下启动 startup.bat ,得到:
    这里写图片描述
    当看到Jenkins is fully up and running 这是跟随我一年半的字眼,激 动的快掉眼泪了,感觉又回到了北京AL…公司,对人生的第一个东家,是 如此的怀恋和感激。
    通过浏览器访问:http://localhost:8080/,得到:
    这里写图片描述
    当你看到上图时,说明我们的 Jenkins 已经安装成功,接下来就是创建任务了,开始我们的持续集成测试了~~。

    昨天,将办公电脑带回来了,公司的新电脑用着就是舒服,流畅,运行起来也够快。
    没有辜负昨天带回的电脑,Jenkins持续集成测试环境,算是搭建成功了,那么接下来如何将web 的test case应用到Jenkins持续集成环境中,且看下回分解。

    展开全文
  • 持续集成开源工具

    2018-11-01 13:58:10
    Jenkins是一个开源软件项目,旨在提供一个开放易用的软件平台,使持续集成变成经济可行 Robot Framework是一款python编写的功能自动化测试框架。具备良好的可扩展性,支持关键字驱动,可以同时测试多种类型的客户端...
  • 围绕自动化测试开展持续集成本文不会介绍持续集成的概念、理论以及相关工具的用法,而是基于实际的项目案例,分享如何利用自动化测试保障持续集成的有效性,同时也借助持续集成提升自动化测试用例的价值。...
  • 按照测试过程分类软件测试大概分为单元测试、集成测试、系统测试、验收测试。以下为软件测试V型图:一般由单元测试开始,集中对每一个程序单元进行测试,检查各个程序模块是否正确地实现了规定的功能。单元测试的...

    测试的分类及必要性

    测试的分类

    测试的过程没太有太严格的分类标准,从使用的角度,我们可以从以下两个角度对测试进行分类。

    按照测试过程分类

    软件测试大概分为单元测试、集成测试、系统测试、验收测试。以下为软件测试V型图:
    软件测试V型图

    • 一般由单元测试开始,集中对每一个程序单元进行测试,检查各个程序模块是否正确地实现了规定的功能。单元测试的测试对象为独立的模块,需要由开发完成。
    • 此外,开发阶段应该还需要通过代码评审等方式,进行静态测试。
    • 集成测试把已测试过的模块组装起来,主要对与设计相关的软件体系结构的构造进行测试,目的在于检验与软件设计相关的程序结构问题。系统测试把已经经过确认的软件纳入实际运行环境中,与其它系统成份组合在一起进行测试,验证软件的完整功能是否满足需求规格并可正常运行。此两个阶段应该由测试人员执行。
    • 在软件的迭代过程中,需要不断重复测试以验证bug修改及新功能添加,这称之为回归测试。
    • 为了快速验证一个新版本,可挑选部分重要测试用例(如出错后会导致阻断其它测试用例的用例)用来验证,称之为冒烟测试(Smoke Test)或接收测试。
    • 验收测试主要由软件的实际用户在实际应用场景中执行,包含α测试和β测试。

    按照测试侧重点的不同分类

    测试可分为功能测试、稳定性测试、性能测试等。
    测试分类及阶段

    • 功能测试用以验证被测试对象功能的正确性。功能是软件最基础的属性,如果功能错误,其他一切测试都没有意义。因此功能测试是其他测试的前提。
    • 性能测试用于验证被测试对象的最大服务负载及其他性能拐点,并通过调查、优化比较给出性能瓶颈、优化建议。
    • 稳定性测试用于验证在一定负载压力情况下,被测试对象长时间运行时功能是否正常。与性能测试的差别在于,稳定性测试的负载不是100%,而且测试的目的在于验证负载下功能的正常,而非验证最大负载。
    • 如果需要,还可以添加场景测试。即根据实际使用情况或猜想得到被测试物的使用场景,在使用场景中进行测试。
    • 其他测试如安全测试、易用性测试,可根据实际需要添加。但是严格来讲,这些都属于功能测试的范畴。

    软件测试的必要性

    发现软件的bug只是手段,软件测试的目的在于保证并提高产品质量。

    如果产品继承自开源社区,开源社区一般有严格的测试标准(如openstack),但是我们仍然需要验证:

    • 我们的部署是否正确?
    • 版本是否适用于我们的环境?有哪些不足值得我们改善?
    • 针对某个bug的修改是否适用于我们的环境?
    • 我们修改或新增后的新特性是否正确?对其他组件是否有影响?

    相关概念

    持续集成测试

    持续集成(Continuous integration)测试,是指在持续基础上不断执行测试以验证完整应用环境正确的行为。“持续”,即要求每次改变提交后,测试工作都要进行。因为需要不断进行回归测试,而且一般都对测试时间有一定要求,因此会大量使用自动化测试。
    持续集成测试

    为什么需要持续集成?

    如果项目开发的规模比较小,对外部系统的依赖很小,那么软件集成不是问题。但是随着软件项目复杂度的增加,就会对集成和确保软件组件能够在一起工作提出了更多的要求。如果开发人员在后期才进行集成,到后期才发现问题,解决问题代价会很大,很有可能导致项目延期或者项目失败。

    因此要求“尽早集成、经常集成”,在早期发现项目风险和质量问题,更容易解决问题,并保证开发进度。持续集成就出现在这样的背景下。

    持续集成测试是一种软件开发实践:团队开发成员经常集成他们的工作,每次集成都通过自动化的构建(包括编译,发布,自动化测试)来验证,从而尽快地发现集成错误。这个过程可以大大减少集成的问题,让团队能够更快的开发内聚的软件从而减少项目整体风险。

    通常当我们提及CI的时候,我们指的是针对完整、现实使用的环境进行的测试。这种测试可以称为集成测试,可以确保提交的针对某个组件的修改不会导致其他组件的失效。集成测试对于如Openstack的多组件多项目的复杂系统尤为重要,而且适用于子系统间没有过多的耦合依赖的情况。

    Openstack的代码评审系统

    Openstack主要使用Gerrit进行代码评审及管理。社区的Gerrit运行于。Gerrit工作流如下:
    gerrit工作流
    当贡献者向Openstack提交一个patch时,他会将代码提交至由Girrit管理的git服务器上。Gerrit控制着哪个用户或组织可以提交代码、合并代码、管理代码库。当贡献者提交代码至review.openstack.org时,Gerrit会创建一个变更集(Changeset)来代表所提交的代码。原提交者和其它贡献者可以对变更集提交额外的修改。Gerrit会收集所有这些更改而汇集成变更集记录。以下为一个待评审的变更集,其中可以看到有很多Patch,而每个Patch都是对原始提交的一次修改。
    gerrit patch界面
    Gerrit中的每个Patch都有三个标签属性。每个人都可以评论变更集或评审代码。在Patch标签属性的“Code-Review”一列中显示了对代码的所有评审:
    gerrit review

    非Openstack核心团队的人员可以在评审代码后作出+1(好)、0(无评价)、-1(不建议合并)的评价。核心团队的成员可以给出非核心成员可给出的所有评价,此外还可以给出+2(好,approved)、-2评价(不要提交)。

    标签属性中另外一列为“Verified”。只有Gerrit的非交互用户(non-interactive users)如Jenkins,才能在此属性上添加Verified标签。Verified一列可设置的值为+1(check pipeline测试通过)、-1(check pipeline测试未通过)、+2(gate pipeline测试通过)、-2(gate pipeline测试未通过)。此外,第三方搭建的外部测试平台也属于非交互用户,但是只能设置+1、-1。

    标签属性中最后一列为Workflow(原为Approve)。只有核心团队的成员可对此列进行标注。此列值只能为+1(Approved)、未通过,展现形式为有无对号标记:
    gerrit verify

    The “Gate”

    这里所说的Gate是一个流程、一个动作,通过这个流程、动作,相关条件达不到的代码将被隔离在源代码分支之外,从而完成对目标代码的“守卫”。
    git工作流
    Openstack采用一种称之为“Non-Human Gatekeeper”的模型来控制代码合并进特定代码分支。Gerrit就是其中的“the non-human”,它允许“Non-Interactive Users”合并代码到它管理的稳定的主干代码分支中。上游的Jenkins服务器以及运行于第三方环境中的Jenkins系统,就属于这些“Non-Interactive Users”。

    那么这些“Non-Interactive Users”如何去判断是否将一个提交的Patch合并进目标代码分支呢?这是通过运行一些相关的测试来实现的。测试内容因项目不同而不同,但大体包括这些内容:单元测试、功能测试、集成测试、升级测试和代码风格测试。“Non-Interactive Users”通过这些测试来守卫(gate)一个特定项目的源代码树。

    大多数Openstack项目都有单元测试和代码风格测试。单元测试在不同的Python版本上执行。风格测试用于验证代码风格是否符合Openstack Hacking和PEP8规定。单元测试和风格测试通过tox调用virtualenvs实现。

    此外,还有针对完整安装的Openstack进行的集成测试。这部分测试时Tempest套件的一部分。最后,很多项目还有升级测试和数据库迁移测试包含在gate test中。

    社区CI环境简介

    背景

    在未出现标准的自动化CI测试套件之前,社区的代码质量基本都由代码评审人员在本地手工测试保证。执行效率低,需要不断重复,而且因为对完整的环境测试很困难导致很难保证某个模块的修改对其它模块是否会产生影响。此外也无法验证在不同环境下是否运行正常。

    而这一切都在社区的自动化CI测试套件出现后得到改善。这是一个完整的、标准化的、鲁棒性高的、自动化的持续集成测试平台,由社区的openstack-infra开发维护。它的核心是Gerrit代码控制评审平台、Zuul驱动的Gating System和Jenkins CI服务器。这个测试系统已被广泛使用,截止2013年9月,社区持续集成测试平台每小时执行720个测试任务,测试节点已增加至328个,不断并行进行测试。截止I版本,社区大概每天有400个测试通过的提交。

    Test Run Style

    根据测试目的、测试精度、测试可靠度等的不同,社区的测试运行方式分为以下五种。

    • Experimental
      根据开发者的需要进行的实验性质的、低可靠度的测试。执行失败后的处理并不由openstack-infra团队负责。
    • Silent
      因为已知问题无法进行的测试。其它同Check。社区会寻找解决办法并评定是否可进入到Check状态。
    • Third Party
      由第三方组织(非Openstack-Infra)在自己的测试环境执行的测试。因为第三方不可控,无法保证测试的可靠度。因此虽然执行后可根据结果对所测试的Patch做出评定,但是只能给出+1、-1,无法做出+2(verified)操作。
    • Check
      Check用于验证每个对Gerrit提交的patch。它和第三方的运行机制相同,都是对提交的patch单独进行测试,而不是针对patch被合并进主代码库后的状态进行测试。
      Check阶段出现的错误会使patch无法被approve,从而无法进入后续状态。
      因此,Check必须在高度可靠地环境中运行,必须由Infra团队完全控制且隔离。
    • Gate
      Gate旨在检测approve通过后的Patch。与Check不同的是,它针对patch被合并进主代码库后的状态进行测试,而不是提交的代码的状态。这样就会检测到Patch直接的语义冲突等问题(鉴于社区每天会有很多patch经过Gate,这样做是很重要的)。
      如果Gate发现错误,将会阻断patch的“着陆”(landing),而且它之后的所有等待的patch都要重新进行测试。
      同Check,Gate也要在高度可靠的环境中运行。

    Openstack CI工作流程

    • (1a)贡献者提交新patch(主要执行Check测试),
      或者
    • (1b)核心团队成员Approve一个patch(主要执行Gate测试),
      之后,
    • (2)Geriit提交一个通知事件到它的事件流中(event stream),
    • (3)Zuul从Gerrit的事件流中读取事件,
    • (4)然后匹配事件到一个或多个pipeline,
    • (5)Zuul针对patch对应的项目执行pipeline(调用Jenkins执行Jenkins jobs),
    • (6)Jenkins被调用来执行具体任务(编译、执行等),并返回结果到Jenkins的事件流中,
    • (7)Zuul从Jenkins的事件流中读取事件,
    • (8)根据结果,Zuul在Gerrit中对patch添加一个review结果。

    Openstack CI工作流程

    社区CI使用的设备

    社区并无自己的设备,所有环境都是Rackspace、HP等云厂商捐赠的虚拟机实例。
    2014年6月:目前大概有340个实例并行执行。实例大多本身运行于Openstack之上,具有8G RAM及相关配置,使用Ubuntu Precise系统。

    组件工作流程

    各组件的工作流程图如下:
    CI各组件工作流程

    Gerrit

    Gerrit主要负责代码的管理,具体可查看之前的章节。在Gerrit将通知事件添加到Gerrit事件流之后,Zuul组件开始发挥作用。

    Zuul

    Zuul通过Gerrit事件,找到对应的pipeline进行后续处理。而pipeline中定义了需要执行哪些Jenkins任务。这些都是在Zuul的配置文件layout.yaml中定义的。例如如下为一个gate这个pipeline的片段:

    
        
    - name: gate
    description: Changes that have been approved by core developers...
    failure-message: Build failed. For information on how to proceed...
    manager: DependentPipelineManager
    precedence: low
    trigger:
    gerrit:
    - event: comment-added
    approval:
    - approved: 1
    - event: comment-added
    comment_filter: (?i)^\s*reverify( (?:bug|lp)[\s #:]*(\d+))\s*$
    start:
    gerrit:
    verified: 0
    success:
    gerrit:
    verified: 2
    submit: true
    failure:
    gerrit:
    verified: -2

    从中我们可以看到gate这个pipeline由gerrit的commit-added + approved或 commit-added +无bug标识的reverify事件触发。成功后会返回verified:2消息给gerrit,失败返回verified:-2。

    类似,check pipeline会被gerrit的patchset-created或recheck事件触发,成功后返回verified:1,失败后返回verified:-1,与Test Run Style描述一致。Openstack的CI环境中主要用到了check、gate、post、pre-release、release、silent、experimental、periodic这几个pipeline,并分别给出了每个项目中这些pipeline对于哪些Jenkins任务。

    而对于每个项目的每个pipeline,需要执行哪些任务,在此配置文件中project一节定义:

    
        
    - name: openstack/cinder
    template:
    - name: python-jobs
    ...snip...
    gate:
    - gate-cinder-requirements
    - gate-tempest-dsvm-full
    - gate-tempest-dsvm-postgres-full
    - gate-tempest-dsvm-neutron
    - gate-tempest-dsvm-large-ops
    - gate-tempest-dsvm-neutron-large-ops
    - gate-grenade-dsvm

    上述配置为对于cinder项目的gate这个pipeline,需要执行gate-cinder-requirement到gate-grenade-dsvm这些任务。

    引入Zuul而不是直接使用Gerrit触发Jenkins的原因是,Jenkins每次只能执行一个任务。这种线性执行是因为考虑到复杂的依赖关系,但是这在需要测试的修改数量增加时就会验证影响效率:如果一个测试需要执行1小时,每天只能执行24次测试,只能对24个修改做出验证。通过引入Zuul使Jenkins并发测试成为可能。

    Zuul同时还可以很好的处理具有复杂依赖关系的多个patch。它能监控正在执行的任务,并可提前结束掉因依赖的patch测试失败而必定失败的测试任务。

    Gearman

    在原来的实现中,Zuul完成“事件-pipeline-任务”的匹配后,就可以调用Jenkins执行具体的任务开始实际的测试了。Jenkins用的是master/slave架构,一台master管理所有slave节点。但是Jenkins的设计初衷并不用于并行执行,它设计中某些点使用到了全局锁,因此在Jenkins的slave节点增加到一定数量后(大约100台),Jenkins的master节点就会出现问题而成为瓶颈。同时master节点是单点部署,无法完成HA等处理。为了扩展Jenkins而引入了Gearman。

    加入Gearman后,Zuul不再与Jenkins直接交互,而是提交执行任务的请求给Gearman服务器,由Gearman服务器完成任务的分发。测试节点通过注册到Gearman服务器,使得Gearman获知其可用,并被分配任务。如Jenkins Master节点通过Gearman的插件连接到Gearman服务器并获得任务。

    通过Gearman,CI测试架构具有了弹性:触发事件的可以不只是Zuul,而执行任务的可以不只是Jenkins。而通过多个Jenkins Master的部署,获得了HA功能。

    Jenkins、JJB

    经过上述流程,终于到了Jenkins实际执行的流程。CI环境中使用的是Master/Salve架构,同一个Master同时控制多个Slave节点进行工作。

    每个Jenkins任务都需要配置Jenkins的config.xml文件实现。而在任务数量达到一定级别后,手工去配置每个任务会变得非常复杂。因此引入了Jenkins Job Builder (JJB)这个Python工具。JJB通过解析用户配置的YAML文件来自动生成config.xml。而YAML文件使用比较易读的语法,支持弹性的模板系统,且支持版本控制便于不断修改。这些特性使得配置大量Jenkins任务变得容易。

    Zuul并不去指定具体Jenkins任务是什么,而是只指定对一个项目的一个pipeline需要去执行哪些Jenkins任务。具体指定每个Jenkins任务的内容是由JJB来做的。

    在Jenkins的任务中,完成对代码的check out、build,然后进行按照定义进行实际的测试。

    Devstack、Nodepool和Backup

    对于单元测试等可能不需要实际的Openstack环境去执行,而对于集成测试等则需要一整套的Openstack组件。对于这些测试, Jenkins任务会去实际搭建完整的Openstack环境。这个工作通过Devstack-Gate调用Devstack脚本实现。但是因为部署也属于Openstack的一部分特性,因此H版本之后社区正在考虑将部署部分也纳入测试项,替代Devstack。

    测试中支持配置不同的组件,如替换数据库PostgreSQL,替换消息队列为ZMQ。

    而在搭建环境之前还需要去申请搭建环境需要的资源(目前社区使用的是虚拟机实例)。Nodepool实现了资源的有效调度,并可方便的添加资源进入资源池。

    在资源使用后,需要清空配置还原环境。这个是通过脚本恢复备份来实现的。

    实际执行的测试用例

    实际执行的测试用例也是在Jenkins的任务中定义,大多通过调用Tempest集成测试套件中的用例实现。

    ELK集群、elastic-recheck

    日志及检索,通过ELK技术栈,实现日志的实时监控:

    • Logstash收集日志,实际环境可考虑使用更加节省资源的Heka替换。
    • Elasticsearch进行日志分析
    • Kibana进行可视化展示
    • elastic-recheck跟踪Openstack Gate失败情况

    其它组件

    • Puppet,用于自动化部署;
    • Cacti等,用于监控。

    测试覆盖内容

    Style测试

    严格的pep8要求,及Openstack自身对代码风格的要求。

    单元测试

    通过Python脚本实现。主要通过python的unittest、mock和nose等单元测试库实现。

    Tempest

    Tempest是一整套Openstack集成测试框架,它的实现基于python的unittest2测试框架和nose测试框架。Tempest对Openstack终端发起一系列API请求,并且对终端的响应进行验证。Tempest通过config文件来描述整个测试环境,包括compute API端点,Keystone server以及Glance server安装的镜像的UUID等信息。

    测试的主要模块有如下几部分:

    • api主要测试OpenStack API部分的功能
    • cli主要测试OpenStack CLI接口
    • scenario主要根据一些复杂场景进行测试
    • stress压力测试部分,目前可以结合rally进行压力测试
    • thirdparty这部分主要针对于EC2的API测试用例。

    稳定性测试

    可以通过改写Tempest实现,增加功能测试的时间、场景的复杂度,增加一定的负载,即可实现满足要求的稳定性测试。

    性能/压力测试

    目前有Rally、scalability testing项目去实现。因为对运行环境有要求、负载压力较大,而且可能包含调优工作(此时可能会改变部署环境等),所以虽然已集成到CI环境中,但后续可能需要单独进行测试。

    其它测试

    很多项目中还在gate的测试中包含升级和数据库迁移测试(如turbo-hipster)。在原有数据量比较大的情况下,就需要考虑升级测试。
    还有很多测试未包含,但是社区在不断完善加入新的测试。

    总结

    使用方式

    作为Openstack开发厂商,如何集成社区的CI框架到我们的开发过程中呢?

    • 测试我们的产品质量
      Openstack社区有兼容性认证,对社区版本做出修改后仍能通过社区测试用例即可获得此认证。
      另外,为社区提交的patch都需要有严格全面的测试用例。
      还可以考虑将社区的CI流程集成进自己的开发流程内,但修改对应的测试用例需要自行编写维护。
    • 为社区捐赠云主机加入社区的测试环境
      可及时获得社区的修改,是否适用于我们的环境,并跟踪bug修改。
      目前各大openstack公有云厂商都有参与。

    问题

    • 测试覆盖不全面
      旧版本只有Nova测试比较多,其他测试待完善。定制化的特性缺少。而且测试大多由开发人员编写,难以保证覆盖度。
      经过几个大版本的更新,测试覆盖度已达到提高,足够满足要求。
      只有在新创建的项目里,测试用例要求不严,覆盖度不高。
    • Gerrit组件带来的修改
      我们现在一般都使用gitlab维护代码。而gerrit本身也最适合只做代码review。
      因此需要迁移代码至gerrit,改变开发review流程,并最终自动同步代码至gitlab。
      相关配置可参考社区文档。
    • 自动化部署
      官方使用devstack进行自动化部署,定制化的部分需要修改。
    • 组件多,部署配置复杂
      部分组件如zuul,是Openstack CI团队独立开发,文档较少。
      而这些组件并非必须,实际环境中乐意考虑简化,最简单的CI框架只需要Gerrit+Jenkins+测试机器+测试用例即可。
    • 社区CI运行于Ubuntu系统
      只有针对此系统的依赖及puppet脚本。
      其它系统部署时在依赖及自动化部署方面可能会遇到很多问题。
    展开全文
  • 持续集成测试(1) – docker-maven-plugin初探背景最近想搞持续集成测试,初步构想是使用git、jekins、maven、docker作为持续集成的基础组件,当然也是最常用的基础组件。 初步是想将java的测试用例塞到docker容器中...
  • Eclipse Hudson是用Java编写的持续集成(CI)工具,它在servlet容器(例如Apache Tomcat或GlassFish应用服务器)中运行。它支持SCM工具,包括CVS,Subversion,Git和Clearcase,并可以执行基于Apache Ant和Apache ...
  • 持续集成工具

    千次阅读 2013-09-26 19:32:34
    持续集成工具已经是铺天盖地,有商业化的软件,也有开源的软件。覆盖的CI功能也是多种多样。 从功能角度分,就笔者的学习经验而言,最关键的是三类:版本控制工具、构建工具、CI(Continuous integration)...
  • 本视频是java自动化测试项目的持续集成教程。持续集成(CI)是一种软件开发实践,它倡导团队开发成员协同工作,有需要的时候就对代码进行集成,不必要等到软件开发后期才开始集成。...运行UT或集成测试
  • 国产持续集成工具 - Gokins 持续集成(Continuous Integration ,CI) 介绍 在传统软件开发过程中,集成通常发生在每个人都完成了各自的工作之后。在项目尾声阶段,通常集成还要痛苦的花费数周或者数月的时间来完成...
  • 持续集成技术与单元测试方法 内容包括以下: 持续集成技术 – 持续集成的基本概念 – 持续集成的作用和优点 – 如何实施持续集成 • 单元测试技术 – 单元测试基本方法 – 单元测试实践中常见的问题 – 单元...
  • Travis CI是在软件开发领域中的一个在线的,分布式的持续集成服务,用来构建及测试在GitHub托管的代码。这个软件的代码同时也是开源的,可以在GitHub上下载到,尽管开发者当前并不推荐在闭源项目中单独使用它。它...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,571
精华内容 39,428
关键字:

工具持续集成测试