Tutorials on 重定向学院

软件测试实质

Tue, 17 Jun 2025 17:29:15 +0800

Ron Patton所著的《软件测试》2002年的中文版，已经十五年了，但它对“软件的实质”的解释仍然是经典，这里摘录与大家分享。

实质，哲学中的本质，又称为“实质”是指某一对象或事物本身所必然固有的。说的通俗点也就是说软件测试的本来的面目。

#### 软件缺陷的定义

来看一下Ron Patton 为我们的软件缺陷所下的定义。

1、软件没有实现产品的说明书所描述的功能。

2、软件实现了产品说明书描述不应有的功能。

3、软件执行了产品说明书没讲的操作。

4、软件没有实现产品说明书没讲但应该实现的功能。

5、从软件测试员的角度来看，软件难以理解、不易使用、运行缓慢，或者最终用户认为不对。

为什么一个定义要这么多条来描述？这个“缺陷”的定义有这么复杂么？不，它其实并不复杂，作者只是想更加全面的来给“缺陷”下定义。

下面我们来以建一栋房子为例，来说明一下每一条定义的意思。需要说明的是没有十分完美而且一成不变的产品说明说，而且在实际项目中，它可能非常简陋，模棱两可，甚至经常变动。

1、软件没有实现产品说明书的描述的功能。房子的主人希望有一个落地的大窗户，让阳光更好的照进屋子里，而且他特意在房子的设计图纸中画出来，并且还加以说明。结果，他看到的是四面全是墙壁，只有一个小门的房子。那么对于测试人员来说，他就是一个缺陷。

2、软件实现了产品说明书中描述的不应有的功能。由于房子的主人生活在南方，天气温暖，而请来的泥瓦匠是北方的，结果给主人建造的房子具然有一个大大的取暖的烟筒，而且主人特意在房子的设计图纸中说明，自己的房子不要烟筒。那么对于测试人员来说，这也是个缺陷。

3、软件执行了产品说明书没讲的操作。与第二条类似，不同的是第二条是主人已经明确说了自己不要烟筒，而这一条强调的是在主人没说的情况下。泥瓦匠自作聪明的加了一个烟筒上去。对于测试人员来说，画蛇添足的功能同样被视为缺陷。

4、软件没有实现产品说明书没讲但应该实现的功能。房子的主要对屋子的高度、格局，材料，颜色描述的非常清楚。泥瓦匠在建造房子的时候发现，主人没有提地基这回事，为了使房子牢固，所以，所有的房子都是必须要先打地基的，虽然主人没有说，但地基的功能必须要做。如果因为没有描述没有去做，但这又一件必须去做的事。对于测试人员来说，也可以视其这缺陷。

5、从软件测试员的角度看，软件难以理解、不易使用、运行缓慢，或者最终用户认为不对。软件测试员是软件除了测试软件运行的缺陷，同样是作为一个用户在再对软件进行使用。如果感觉自己都很难使用，或软件效率非常低且界面丑陋等情况，也可以认为其存在缺陷。或者是最终用户拿到产品时发现这根本不是自己想要的东西，也可以现其为缺陷。当然，用户说不是自己想要的东西，也不能凭借一面之词，可以拿合约，产品说明书来评估。

#### 完全测试程序的可能性

初做软件测试者可能认为拿到软件后就可以进行完全测试了，找出所有软件缺陷，并使软件完美。遗憾的是这是不可能的，我们无法对一个软件进行完全测试，即使最简单的程序也不行。主要原因如下：

输入量太大
输出结果太多
软件实现的途径太多
软件说明书没有客观标准。从不同的角度看，软件缺陷的标准不同

以上的“太多”的可能性加在一起，致使测试条件难以确定。

以126邮箱为登录测试为例，其用户长度为50个字符，密码确实不太好计算（因为都是*号），所以这里也按50个字符来计算。

在输入正确用户名的情况下：

1、输入正确的密码名是还否可以登录，

2、那么错误输入0 呢？1呢？2呢？......直到

99999999999999999999999999999999999999999999999999 ，

3、如果密码不是数字，而是字符呢，a 、b、c ... aa、bb 、cc .....

4、如果是大写呢 A 、B、C.... AA 、BB、CC.....

5、如果是大小写呢 Aa、Ab ....

6、如果是小写+数字呢 1a 、1b 、1c ....2a 、2b 、2c.....

7、如果是大写+数字呢 1A 、1B 、1Cc....2A 、2A 、2A.....

8、如果是大写+小写+数字呢 1Aa 、1Bb 、1Cc ....1Aa 、1Bb 、1Cc.....

9、如果有特殊字符呢 @#￥%……&*

10、如果输入字符有空格呢 a b、adbc ee......

11、如果是其它字符+大小写字母+数字呢+空格呢 ！@#&+123AIBKIkklzcb ......

......

12、再换正确的密码，错误的文件名再来一次。

13、用错误的用户名和密码再把上面的情况验证一次。（这样会匹配到所有的用户名密码）

14、什么都不输，直接点击登录

这样穷举下去，就算是计算机也可能需要运行很久。如果觉得某些测试条件是重复的或者是无必要的，而将其剔除，那么就不能称为完全测试。

wrk系列教程(1)安装

Fri, 01 Mar 2019 02:00:11 +0800

wrk是一个高性能的性能测试工具，具有非常强的并发能力，很适合做benchmark。

wrk适合做一些简单的单接口性能压测，具有一定的扩展能力，不太适合做全链路的带业务压测。

下载源码

首先你需要1台linux虚拟机或者mac机器。

如果你用使用git，可以使用下面命令来下载源码

git clone https://github.com/wg/wrk.git

或者你可以使用wget来下载源码的压缩包，并自行解压

wget https://github.com/wg/wrk/archive/master.zip

安装wrk

cd到wrk源码所在目录，运行

make

如果一切正常，一段时间后wrk会自动编译完成。我们可以将编译出的wrk可执行文件拷贝到/usr/local/bin中，这样调用起来会比较方便。

如果需要定制化安装，你可以参考这里

验证安装

运行wrk可执行程序，你应该看到下面的结果

Usage: wrk <options> <url>
 Options:
 -c, --connections <N> Connections to keep open
 -d, --duration <T> Duration of test
 -t, --threads <N> Number of threads to use

 -s, --script <S> Load Lua script file
 -H, --header <H> Add header to request
 --latency Print latency statistics
 --timeout <T> Socket/request timeout
 -v, --version Print version details

 Numeric arguments may include a SI unit (1k, 1M, 1G)
 Time arguments may include a time unit (2s, 2m, 2h)

原始封面

python简明教程: 1. 基本数据类型及操作

Thu, 22 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者


# 以```#```开头进行单行注释

""" 使用3个双引号
 来定义多行文本
 多行文本一般被用来
 做注释用了
"""

# 这是数字
3 # => 3

# 这是做简单的算术
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7

# 除法有点不太一样，除法默认是做整数除法，比如
5 / 2 # => 2

# 我们一般所认知的除法在python里其实就是浮点数除法，嗯，首先要了解什么是浮点数(floats)
2.0 # 这就是浮点数了
11.0 / 4.0 # => 2.75 嗯...好多了

# 可以强制返回整数，正数负数都可以了
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # 浮点数也行
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0

# 注意，我们可以可以import division 模块(关于import教程第6节会有涉及)
# 这样 '/' 就可以实现普通的我们所熟悉的除法功能了
# 貌似python3里面'/'默认就是普通除法模式
from __future__ import division

11 / 4 # => 2.75 ...普通除法
11 // 4 # => 2 ...取整除法

# 模/取余操作
7 % 3 # => 1

# 乘方 (x 的 y 次方)
2 ** 4 # => 16

# 用括号强制改变算术的结合律
(1 + 3) * 2 # => 8

# 布尔值的操作或者叫逻辑运算
# 注意 "and" 和 "or" 是区分大小写的
True and False # => False
False or True # => True

# 注意布尔操作跟整数搅在一起的时候
0 and 2 # => 0
-5 or 0 # => -5
0 == False # => True
2 == True # => False
1 == True # => True

# 用not来逻辑取反
not True # => False
not False # => True

# 相等判断用 ==
1 == 1 # => True
2 == 1 # => False

# 不等用 !=
1 != 1 # => False
2 != 1 # => True

# 更多的比较
1 < 10 # => True
1 > 10 # => False
2 <= 2 # => True
2 >= 2 # => True

# 比较可以串起来
1 < 2 < 3 # => True
2 < 3 < 2 # => False

# 用 " 或 ' 来创建字符串
"This is a string."
'This is also a string.'

# 字符串也是可以相加的!
"Hello " + "world!" # => "Hello world!"
# 不用 '+' 号也能加
"Hello " "world!" # => "Hello world!"

# ... 甚至可以相乘
"Hello" * 3 # => "HelloHelloHello"

# 字符串可以当成是字符组成的列表
"This is a string"[0] # => 'T'

# 可以拿到字符串的长度
len("This is a string") # => 16

# 可以用 % 来格式化字符串
# Even though the % string operator will be deprecated on Python 3.1 and removed
# 即使 % 操作在Python 3.1以后会被废弃和移除
# 不过知道这些代码是如何工作的总不是坏事
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s" % (x, y)

# 新一点的格式化字符串的方式是使用format方法
# 这个方法更好一些
"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted")
# 如果你不想数数的话，你还可以使用关键字
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

# None是一个对象
# 所以你是有对象的
None # => None

# 不要使用 "==" 符号进行对象和None的比较
# 要使用 "is"
"etc" is None # => False
None is None # => True

# 'is'符号用来测试对象的之间的相当性
# 在比较基本类型的时候可能用处不大
# 不过用在对象的比较方面却是很有用的

# Any object can be used in a Boolean context.
# 任何的对象都可以在布尔值的上下文中使用
# 下面的值会被认为是false的
# - None
# - zero of any numeric type (e.g., 0, 0L, 0.0, 0j)
# - 任何数字类型的0 (比如, 0, 0L, 0.0, 0j)
# - 空序列 (比如, '', (), [])
# - 空的容器类型 (比如, {}, set())
# - 某些情况下用户自定义的类的实例
# 见: https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
#
# 其他的值都被认为是true(使用bool()测试这些值的时候会返回True).
bool(0) # => False
bool("") # => False

原始封面

（一）Docker介绍

Mon, 22 Jan 2018 14:55:11 +0800

什么就Docker?

Docker是一个开源项目，诞生于2013年初，最初是dotCloud公司内部的一个业余项目。它基于Google公司推出的Go语言实现。项目后来加入了Linux基金会，遵从了Apache 2.0协议，项目代码在GitHub 上进行维护。

Docker项目的目标是实现轻量级的操作系统虚拟化解决方案。Docker的基础是Linux容器（LXC）等技术。在LXC的基础上Docker进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作Docker的容器就像操作一个快速轻量级的虚拟机一样简单。

为什么要使用Docker?

Docker 相比传统虚拟机有诸多优势。

启动速度更快： 秒级启动。
快速的部署和交付： 开发者可以使用一个标准的镜像来构建一套开发容器，开发完成之后，运维人员可以直接使用这个容器来部署代码。
更高效的虚拟化： 它是内核级的虚拟化，因此可以实现更高的性能和效率。
高效的迁移： Docker可以运行在不同的平台，用户可以轻松的将一个应用从一个平台迁移到另一个平台。
节省开支： Docker容器除了运行其中应用外，基本不消耗额外的系统资源，一台设备可以运行上千个容器。

Docker基本概念

Docker包括三个基本概念

镜像（Image）

Docker提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下载一个已经做好的镜像来直接使用。镜像可以用来创建Docker容器。

容器（Container）

容器是从镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

仓库（Repository）

仓库是集中存放镜像文件的场所。仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub，存放了数量庞大的镜像供用户下载。中国官方镜像加速

原始封面

（一）从这里开始

Wed, 17 Jan 2018 14:55:11 +0800

其实，本Java教程是写给自己的，所以，肯定不是零基础，也不会告诉你Java有多么的好，也不会吹嘘它能做多少事情。

这里简单的总结一下对我编程语言的学习过程。我真正在开始学习Java是在2010年的时候，当时是希望找一份Java开发的工作，于是，开始看马士兵、李兴华他们的Java视频教程。可以跟着例子敲，但关掉它们的视频，我却写不出一行代码。

归结原因有两点：

自己基础太差，大学时没有培养自己的编程能力，除了对C语言有些了解。再加上自己确实比较笨。
没有以需求驱动，也不具备这样的能力。总之，也不知道自己学的这些代码和工作中的项目有什么直接关系。边学边忘。

后来，在工作中，我开始学Python，这一次很清楚自己要python + Selenium实现自动化，再加上整个项目组用Python开发社区的项目，耳听目染的达到了学以致用的目的。我觉得一部分原因是因为Python确实简单，另一方面是有这样的学习环境。

再回过头来学Java的时候，我是边用边学的，因为有Python的基础，再加我很明确要用Java实现什么功能。但是，对Java语言中的诸多概念仍然处于模糊状态。

所以，通过整理该系列文章的同学，自己再系统的梳理一下Java的知识。

学编程无技巧，多练，多思考。

Java环境的搭建，参考：环境安装之Java

开发工具为IntelliJ IDEA，参考：环境安装之IntelliJ IDEA ，更系统的教程：《IntelliJ-IDEA-Tutorial》

原始封面

TDD实战（一）开发模式

Mon, 08 Jan 2018 12:59:11 +0800

TDD 介绍

TDD是测试驱动开发（Test-Driven Development）的英文简称，是敏捷开发中的一项核心实践和技术，也是一种设计方法论。TDD的原理是在开发功能代码之前，先编写单元测试用例代码，测试代码确定需要编写什么产品代码。TDD虽是敏捷方法的核心实践，但不只适用于XP（Extreme Programming），同样可以适用于其他开发方法和过程。

– 百度百科

准备工具

TDD只是一种开发模式，它并没有用到新的技术。

Java : 因为它是主流的编程语言，应用广泛，相关实践也非常多。
IntelliJ-IDEA : Java 主流IDE（集成开发工具）。
JUnit ： Java 主流单元测试框架，当然，你选择 TestNG 也是完全可以的。
Gradle : 构建工具。

TDD 开发模式

“红灯 – 绿灯 – 重构” 流程是TDD的基石。这个过程就像打乒乓球，快速的在测试代码和实现代码之间切换。

TDD 开的过程：每次只考虑一个需求。首先编写一个测试，看看它是否未通过；然后编写实现这个测试的代码，运行所有测试并验证它们是否全部通过；最后，通过重构改进代码。不断重复这个过程，直到成功实现所有需求。

需求

本系列实战 “井字游戏” ，这是一个非常简单的小游戏。

说明：

是一种在3*3格子上进行的连珠游戏，和五子棋比较类似，由于棋盘一般不画边框，格线排成井字故得名。游戏需要的工具仅为纸和笔，然后由分别代表O和X的两个游戏者轮流在格子里留下标记（一般来说先手者为X）。由最先在任意一条直线上成功连接三个标记的一方获胜。

不会玩的同学可以先去完两把：井字小游戏。

原始封面

Android测试（一）：在Android中测试App

Wed, 20 Dec 2017 14:55:12 +0800

原文：https://developer.android.com/training/testing/index.html

测试你的App是开发过程中的重要组成部分。通过对应用程序持续的运行测试，你可以验证程序的正确性、功能和可用在发布之前。

测试还提供了以下优点：

快速反馈失败。
开发周期的早期问题检测。
安全地重构代码，让你优化代码而不用担心回归。
稳定开发速度，帮助你减少技术债务。

这里的特指测试通过代码实现的“单元”测试。所以，它可以更早、更快的帮我们发现问题，使我们的代码重构更有信心；单元测试虽然前期编写会比较耗时，但是它可以有效的代码的质量，不会导致项目后期代码充满坏味道，严重拖慢开发进度；所以，减少你技术债务。

资源

在Android测试库、Android平台和开源社区都提供了帮助你编写Android应用测试的工具：

Espesso

Espresso是android应用开发自带测试库。他是一款白盒风格的UI测试工具。UI测试就都是黑盒的么？为什么会是白盒风格。

说白盒是因为，通过Espresso编写测试调用Android控件的方式和 Android开发中是一样的。来看一段Android开发中，Activity中编写的代码。

/** Called when the user clicks the Send button */
public void sendMessage(View view) {
 // Do something in response to button
 Intent intent = new Intent(this, DisplayMessageActivity.class);
 EditText editText = (EditText) findViewById(R.id.edit_message);
 String message = editText.getText().toString();
 intent.putExtra(EXTRA_MESSAGE, message);
 startActivity(intent);
}

通过 R.id.edit_message 调用布局文件中输入框中的内容，并转交到另外一个Activity处理。

Fiddler（一）介绍与安装

Tue, 19 Dec 2017 13:59:11 +0800

Fildder是一款免费的web调试代理工具，支持任何浏览器、系统或平台。

官方网站：https://www.telerik.com/fiddler

工作原理

Fiddler是以代理Web服务器的形式工作的,浏览器与服务器之间通过建立TCP连接以HTTP协议进行通信，浏览器默认通过自己发送HTTP请求到服务器，它使用代理地址:127.0.0.1, 端口:8888。

开启Fiddler后，通过浏览器访问：http://127.0.0.1:8888

安装

点击这里下载Fiddler。不过，更简单的方式是直接在百度中搜索，通过百度软件中心下载。

安装过程这里省略。启动Fiddler，主界面如下：

原始封面

爬虫介绍

Mon, 18 Dec 2017 02:52:34 +0800

什么是爬虫

爬虫实际上就是采集网络上数据的一段程序，如果把互联网比喻成一个蜘蛛网，那么蜘蛛就是在网上爬来爬去的蜘蛛，爬虫程序通过请求url地址，根据响应的内容进行解析采集数据，比如：如果响应内容是html，分析dom结构，进行dom解析、或者正则匹配，如果响应内容是xml/json数据，就可以转数据对象，然后对数据进行解析。

资源视角

互联网上一切都是资源，比如视频资源，新闻资源等，爬虫实际上就是批量将别人的资源采集下来变成自己的资源的程序。

爬虫的一些例子

从其他网站爬取特定类型的商品信息，然后发布在自己的网上商城里
从其他网站爬取一些特定图片，展示在自己的网站里
搜索引擎爬取网站基本信息，收录在自己的搜索结果里

最简单的爬虫套路

访问1个站点，获取该站点的html代码
解析html代码，把感兴趣的数据从html代码里分离出来
保存这些数据

实际例子

假设我需要抓取重定向科技目前开设的所有测试课程，那么

先访问所有课程页面，把html代码拿到
解析html代码，从里面抠出来课程的名称和详情地址
保存课程的名称和地址

这样就可以实现一个最简单的网络爬虫了。

爬虫对于测试的意义

有时候自己去造一些测试数据是很麻烦的事情，这时候我们就可以使用爬虫去获取其他站点的类似数据，对数据进行加工后就可以当测试数据来使用了。

Reference

大话爬虫的基本套路
推荐另一个不错的python爬虫教程，应该是基于python2.7

原始封面

（一）Maven 介绍

Sat, 25 Nov 2017 12:55:11 +0800

Apache Maven 是一个软件项目管理的综合工具。基于项目对象模型（POM）的概念，Maven 可以从一个中心资料片管理项目构建，报告和文件。本章将和你一起学习 Maven 的基本使用。

官方网站：http://maven.apache.org/

Maven 介绍？

Maven 是一个项目管理和综合工具。 Maven 提供了开发人员构建一个完整的生命周期框架。开发团队可以自动完成项目的基础工具建设， Maven 使用标准的目录结构和默认构建生命周期。在多个开发团队环境时， Maven 可以设置按标准在非常短的时间里完成配置工作。由于大部分项目的设置都很简单，并且可重复使用， Maven 让开发人员的工作更轻松，同时创建报表，检查，构建和测试自动化设置。

Maven 提供了开发人员的方式来管理：

Builds
Documentation
Reporting
Dependencies
SCM（Software Configuration Management）
Releases
Distribution
mailing list

概括地说， Maven 简化和标准化项目建设过程。处理编译，分配，文档，团队协作和其他任务的无缝连接。 Maven 增加可重用性并负责建立相关的任务。

为什么学习 Maven？

不学习 Maven 不能做 Java 开发么？当然不是，但是随着你 Java 开发越用越熟悉，涉及到第三方包也会越来越多，比如 web开发，自动化测试，这里面会用到大量的第三方库，不同库之间的依赖关系，如何快速有效果的管理这些库；以及在多人开发的团队中，如何有效的保证每个开发人员所使用的第三方库的一致性。这个时间 Maven 就起来了非常重要的作用。

原始封面

（一）mock 与 Mockito 介绍

Sat, 25 Nov 2017 12:55:11 +0800

什么是mock ？

mock在翻译过来是模拟的意思。这里要介绍的mock是辅助单元测试的一个模块。它允许你用模拟对象来替换你的系统的部分，并对它们已使用的方式进行断言。

什么意思呢？说的直白些，我们要测试一个模块（类、方法或接口），但是这个模块还没有实现，或者它属于第三方模块，真的去调用会比较麻烦，这个时候就可以借助 mock 技术，给该模块设置预期结果。

可能你和我一样会有疑问，把要测试的模块都mock掉了，这不是自己骗自己嘛，那我们还测什么？

但是，在实际生产中的项目是非常复杂的，对其进行单元测试的时候，会遇到以下问题：

接口的依赖
外部接口调用
测试环境非常复杂

单元测试应该只针对当前单元进行测试, 所有的内部或外部的依赖应该是稳定的, 已经在别处进行测试过的.使用mock 就可以对外部依赖组件实现进行模拟并且替换掉，从而使得单元测试将焦点只放在当前的单元功能。

mock技术的目的和作用就是模拟一些在应用中不容易构造或者比较复杂的对象，从而把测试与测试边界以外的对象隔离开。

什么是 Mockito ?

官方网站：http://site.mockito.org/

Tasty mocking framework for unit tests in Java

优雅的mock框架用于Java的单元测试。

GitHub 地址：https://github.com/mockito/mockito

安装 Mockito

以 Maven 方式安装为例。

 <dependency>
 <groupId>org.mockito</groupId>
 <artifactId>mockito-all</artifactId>
 <version>2.0.2-beta</version>
 <scope>test</scope>
</dependency>

因为 Mockito是其于单元测试的框架，所以，接下来的练习最好在单元框架框架下运行，通过 Maven 配置 JUnit 单元测试框架。

<dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 <scope>test</scope>
</dependency>

原始封面

（一）TestNG介绍与安装

Sat, 25 Nov 2017 12:55:11 +0800

介绍

TestNG 官方网址：http://testng.org/doc/

TestNG是一个测试框架的灵感来自JUnit和NUnit,但引入一些新的功能，使它更强大和更容易使用，如：

注释。
在任意大线程池中运行测试，并提供各种策略（所有方法都在自己的线程中，每个测试类有一个线程，等等）。
测试你的代码多线程是安全的。
灵活的测试配置。
数据驱动的测试支持（@dataProvider）。
参数支持。
强大的执行模型(不再有TestSuite)。
通过各种工具和插件支持（Eclipse, IDEA, Maven 等..）。
通过进一步的灵活性Beanshell。
运行时和日志的默认JDK功能(无依赖性)。
应用服务器测试的相关方法。

TestNG 表示下一代(Next Generation的首字母)。它的设计覆盖所有类别的测试：单元、功能、端到端、集成等。

安装

本教程基于 IntelliJ IDEA 和 Maven ，所以，这里只介绍 Maven 的安装方式。

<!-- https://mvnrepository.com/artifact/org.testng/testng -->
<dependency>
 <groupId>org.testng</groupId>
 <artifactId>testng</artifactId>
 <version>6.13</version>
 <scope>test</scope>
</dependency>

原始封面

如何安装requests?

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

官方给出的安装方式是使用pipenv

pipenv install requests

当然也可以直接使用pip安装

pip install requests

还可以从源码安装

git clone git://github.com/requests/requests.git
cd requests
pip install .

原始封面

（一）JUnit 介绍

Mon, 13 Nov 2017 12:59:11 +0800

什么是单元测试？

单元测试负责对最小的软件设计单元（模块）进行验证，它使用软件设计文档中对模块的描述作为指南，对重要的程序分支进行测试以发现模块中的错误。

单元测试是个听起来高大上的话题，貌似只有白盒测试或开发人员才能胜任这项工作。其实，它并没有想象的那么高级。

什么是单元测试框架？

对于单元测试框架来讲，它主要完成以下几件事。

提供用例组织与执行： 当你的测试用例只有几条时，可以不必考虑用例的组织，但是，当测试用例达到成百上千条时，大量的测试用例堆砌在一起，就产生了扩展性与维护性等问题，需要考虑用例的规范与组织问题了。单元测试框架就是用来解决这个问题的。。

提供丰富的断言方法： 不论是功能测试，还是单元测试，在用例执行完成之后都需要将实际结果与进行预期结果的进行比较（断言），从而断定用例是否执行通过。单元测试框架一般会提供丰富的断言方法。例如，判断相等/不等、包含/不包含、True/False的断言方法等。

提供丰富的日志： 当测试用例执行失败时能抛出清晰的失败原因，当所有用例执行完成后能提供丰富的执行结果。例如，总执行时间、失败用例数、成功用例数等。

从这些特性来看单元测试框架的作用是：帮助我们更自动化测试完成测试，所以，它是自动化测试的基础。

什么是 JUnit？

Junit 官网：http://junit.org/

JUnit 是一个编写可重复测试的简单框架。它是单元测试框架的 xUnit 架构的一个实例。

原始封面

1. 基本概念

Thu, 09 Nov 2017 06:23:31 +0800

unittest是python自带的单元测试框架，有时候又被称为"PyUnit"，是python版本的JUint实现。

该框架的作者是 Kent Beck和Erich Gamma，感谢祖师爷赏饭吃。

在学习使用unittest库之前，我们需要了解一下unittest库的一些重要概念:

test fixture: 代表了用例执行前的准备工作和用例执行之后的清理工作。比如在用例执行前创建临时文件和文件夹，又或者启动1个server进程等；
test case: 测试用例，这个相信大家都不陌生。是测试的最小单位，一般检查一组输入的响应(输出)是否符合预期。unittest模块提供了TestCase类来帮助我们创建测试用例；
test suite: 经常被翻译成"测试套件"，也有人称为"测试套"，是测试用例或测试套件的集合，一般用来把需要一起执行的用例组合到一起;
test runner: 用来执行测试用例并输出测试结果的组件。可以是图形界面或命令行界面;

总之

test fixture的功能可以理解成是初始化和清理测试数据及环境
test case是测试用例
test suite是用例集合
test runner的作用是运行用例并返回结果

原始封面

1. 第一个程序

Tue, 07 Nov 2017 08:17:22 +0800

背景

我们的第一个python程序将要实现最简单的打印测试报告的功能。

我们希望可以将回归测试的结果打印到命令行窗口里。测试结果如下所示

本次测试功能点5个
测试用例20个
共执行测试用例20个
共发现缺陷0个
用例通过率100%

代码实现

新建名为print_report.py的文本文件，用文本编辑器打开，输入如下内容:

print('本次测试功能点5个')
print('测试用例20个')
print('共执行测试用例20个')
print('共发现缺陷0个')
print('用例通过率100%')

运行

在命令行中使用下面的命令去执行代码

python print_report.py

注意: 初学者一般不知道如何在命令行中cd进具体的文件夹，macos可能相对简单一些，对于使用windows的同学来说，cd到具体的文件夹需要两步

比如我们需要cd到E:\code文件夹，那么步骤应该是

首先敲盘符E:，然后回车，表示进入E盘先
然后敲cd code并回车，表示进入code目录

你应该可以看到

如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

本次测试功能点5个
测试用例20个
共执行测试用例20个
共发现缺陷0个
用例通过率100%

如果你遇到错误，那么很多情况下可能会提示

python print_report.py // 1
 File "print_report.py", line 4 // 2
 print('共发现缺陷0个) // 3
 ^ // 4
SyntaxError: EOL while scanning string literal // 5

作为初学者，把代码尽可能敲正确和看懂错误提示是非常关键的两件事。

我们在写代码的时候经常会遇到各种各样的错误提示，我们一般可以从错误提示里获得如下的信息

哪一行代码出错了
出错的原因具体是什么

现在我们来具体分析上面的错误信息

我们运行了名为的print_report.py的脚本
pytnon告诉我们print_report.py的文件的第4行有错误
python把出错行的内容打印出来
然后python通过^字符告诉我们错误具体发生在哪里。可以看出我们漏掉了一个单引号
最后python告诉我们具体的错误是什么，这里是"SyntaxError"。一般情况下，我们可以把错误信息，也就是SyntaxError: EOL while scanning string literal这一行直接拷贝到搜索引擎里去搜索具体的解决方案，大部分情况下，我们都可以得到满意的结果

动手时间

尝试去做下面一些事情

1.快速开始

Thu, 02 Nov 2017 07:22:42 +0800

简介

pytest测试框架可以让我们很方便的编写测试用例，这些用例写起来虽然简单，但仍然可以规模化以及编写更加复杂的测试用例。

官方文档

安装

pip install -U pytest

用下面的命令去检查一下pytest是否成功安装

$ pytest --version
This is pytest version 3.x.y, imported from $PYTHON_PREFIX/lib/python3.5/site-packages/pytest.py

快速开始

创建名为test_quick_start.py的文件，敲如下内容

def reverse(string):
 return string[::-1]

def test_reverse():
 string = "good"
 assert reverse(string) == "doog"

 another_string = "itest"
 assert reverse(another_string) == "tseti"

上面的代码做了2件事情

定义了名为reverse(string)的全局函数，作用是把string反转并返回。比如输入"abc"会反转成"cba"
定义了名为test_reverse()的函数，包含了2个断言，用来测试reverse()方法的正确性

在命令行中使用下面的命令去运行用例

pytest

结果应该大致如下

========================================================================= test session starts =========================================================================
platform darwin -- Python 2.7.12, pytest-3.2.3, py-1.4.34, pluggy-0.4.0
rootdir: /Users/easonhan/code/testclass.net/src/pytest, inifile:
collected 1 item

test_quick_start.py .

====================================================================== 1 passed in 0.01 seconds =======================================================================

总结

这是最简单的单元测试实例，实现了用代码去测试代码的目的。

原始封面

1. webium简介及安装

Sun, 29 Oct 2017 06:55:26 +0800

webium是基于python的一个Page Object实现, API简单友好，可以在一定程度上提升Web UI测试的生产力，值得我们进行学习。

不过注意: webium要配合selenium一起使用。

用有的链接

安装

pip install webium

常用类

一般来说我们会经常用到下面几个类

webium.Find: 在page中定位单个元素
webium.Finds: 在page中定位一组元素
webium.BasePage: 页面的基类，其他页面都必须是该类的子类

使用方式

下面以百度搜索重定向科技为例

# baidu.py
from selenium import webdriver
from selenium.webdriver.common.by import By
from webium import BasePage, Find, Finds
import time

class BaiduPage(BasePage):
 url = 'https://www.baidu.com'

 keyword = Find(by=By.ID, value='kw')
 button = Find(by=By.ID, value='su')

class ResultsPage(BasePage):
 first_result = Find(by=By.CSS_SELECTOR, value='.result')

if __name__ == '__main__':
 dr = webdriver.Chrome()

 baidu_page = BaiduPage(driver=dr)
 baidu_page.open()

 baidu_page.keyword.send_keys('重定向科技')
 baidu_page.button.click()
 time.sleep(3)

 results_page = ResultsPage(driver=dr)
 print(results_page.first_result.text)

 dr.quit()

运行及结果

python baidu.py

重定向科技
重定向科技(www.itest.info)致力于培养中国软件测试行业中高端人才,公司长年专注于软件测试教育领域,拥有先进的软件测试教育体系,向个人和企业客户提供领先的软件测试...
itest.info/ - 百度快照

原始封面

收藏清单:Java测试相关资源汇总

Fri, 27 Oct 2017 08:19:06 +0800

Virtual environments 虚拟化环境

Vagrant - 配置简单可信赖的虚拟化环境管理工具
Docker - docker就不用多说了

Performance & stress & load 性能测试

Apache JMeter - 支持性能及功能测试
The Grinder - 使用多台测试机运行分布式性能测试的框架
Lightning - 融合JMeter，不支持功能测试，支持CI/CD
Tsung - 基于Erlang的性能测试工具，支持多协议
Gatling - Gatling是基于Scala, Akka 和 Netty的开源性能测试框架. 非常适合做压力测试。它的设计初衷是易用，好维护和高性能。 DSL易于理解，测试场景可以自解释，脚本维护简单，可以直接在代码库中进行管理。

Build Tools 构建工具

Apache Ant - 不用多解释了，构建java项目的自动化工具
Apache Maven - Apache Maven 是软件项目管理的综合工具. 基于 project object model (POM), Maven可以从中心信息管理项目构建,报告及文档
Gradle - Gradle 是开源的自动化构建系统。 Gradle可以自动化的构建，测试，发布及部署。

Continuous Integration 持续集成

jenkins - 可扩展的开源持续集成server
TeamCity - 功能强大，用户友好的持续集成及部署工具，开箱即用

Reporting 报告

ReportPortal - 强大的服务端报告工具。降低了处理结果的工作量。提供了测试执行的历史数据，日志截图以及任意二进制文件的记录和存储。
Allure - 开源框架，目的是为团队中的每个人创建清晰的测试报告。
Gradle Allure Plugin - 第三方的 Gradle Allure插件可以将Allure集成到spock, testing 和junit用例中。
ExtentReports - HTML报告库支持.NET和Java，使使用简单，可以创建美观的测试报告。
ReportNG - ReportNG 是一个简单的 TestNG HTML报告插件。

Editors, IDE, consoles 编辑器 IDE

IntelliJ IDEA - 免费开源的IDE 支持 Java, Groovy, Scala 和 Android 开发
- IntelliJ IDEA Selenium plugin - IntelliJ Idea 插件，使selenium用例编写更简单。
Eclipse - 最有名的JavaIDE同时也支持 C/C++和PHP
- Genie plugin - 测试AS 3.0 SWF和Flash游戏的功能测试工具
NetBeans - NetBeans IDE 是Java 8的官方IDE

ORM frameworks and libraries ORM框架和库

Hibernate - SSH里的H
Morphia - Morphia一款是轻量的类型安全的MongoDB对象mapping库
MyBatis - MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

Useful libs 有用的库

StreamEx - Java 8 Streams加强库。
Vavr - Vavr 是Java 8的object-functional 语言扩展, 目的是减少代码行数和增强代码质量。
Lombok - Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。
AspectJ - Java的面向切面编程工具.
aShot - WebDriver 截图工具.
rest-assured - 用Java来测试REST服务比动态语言比如Ruby Groovy要难。 REST Assured 可以给Java带来类似动态语言测试REST服务的体验
WireMock 灵活的 web 服务mock库，跟一般的mock目的不同的是，WireMock使用了真实的web服务
MockServer 可以用来mock任何基于HTTP和HTTPS的系统 (比如services, web sites,等).
XMLUnit - 测试和比较 XML，支持 Java 和 .NET
Awaitility - Awaitility是测试异步代码的库
Beanmother - 初始化Java Bean作为test data的库

Resources 资源

Websites 网站

automated-testing.info - 自动化测试社区
atinfo.github.io/at.info-knowledge-base - 各种工具和技术实现的自动化测试的例子
测试教程网: 最权威的中文测试教程汇总网站
selenium-simplified - 让selenium webdriver测试更简单

原始封面

（一）Locust 介绍

Mon, 16 Oct 2017 14:00:11 +0800

Locust 官方网站：https://www.locust.io/

Locust 介绍

An open source load testing tool.

一个开源性能测试工具。

define user behaviour with python code, and swarm your system with millions of simultaneous users.

使用 Python 代码来定义用户行为。用它可以模拟百万计的并发用户访问你的系统。

#### 性能工具对比 ---- __LoadRunner__ 是非常有名的商业性能测试工具，功能非常强大。使用也比较复杂，目前大多介绍性能测试的书籍都以该工具为基础，甚至有些书整本都在介绍 LoadRunner 的使用。

Jmeter 同样是非常有名的开源性能测试工具，功能也很完善，在本书中介绍了它作为接口测试工具的使用。但实际上，它是一个标准的性能测试工具。关于Jmeter相关的资料也非常丰富，它的官方文档也很完善。

Locust 同样是性能测试工具，虽然官方这样来描述它 “An open source load testing tool.” 。但其它和前面两个工具有着较大的不同。相比前面两个工具，功能上要差上不少，但它也并非优点全无。

Locust 完全基本 Python 编程语言，采用 Pure Python 描述测试脚本，并且 HTTP 请求完全基于 Requests 库。除了 HTTP/HTTPS 协议，Locust 也可以测试其它协议的系统，只需要采用Python调用对应的库进行请求描述即可。

（一）持续集成与 Jenkins 介绍

Mon, 16 Oct 2017 14:00:11 +0800

#### 持续集成 ---- 持续集成（Continuous integration，简称 CI），随着近几年的发展，持续集成在项目中得到了广泛的推广和应用。本章将带领读者一起了解持续集成工具 Jenkins 的安装与使用。

1．什么是持续集成？

软件集成就是用一种较好的方式，使多种软件的功能集成到一个软件里，或是把软件的各部分组合在一起。如果项目开发的规模较小，且对外部系统的依赖很小，那么软件集成不是问题，例如一个人的项目。但是随着软件项目复杂度的增加，会对集成和确保软件组件能够在一起工作提出了更多的要求–>要早集成、常集成。早集成、频繁的集成能够帮助项目开发者在早期发现项目风险和质量问题，越到后期发现的问题，解决的成本越高，从而有可能导致项目延期或者项目失败。

2．定义

大师 Martin Fowler 对持续集成是这样定义的：持续集成是一种软件开发实践，即团队开发成员经常集成他们的工作，通常每个成员每天至少集成一次，也就意味着每天可能会发生多次集成。每次集成都通过自动化的构建（包括编译、发布、自动化测试）来验证，从而尽快地发现集成错误。许多团队发现这个过程可以大大减少集成的问题，让团队能够更快地开发内聚的软件。

#### Jenkins ----

Jenkins 官方网站：https://jenkins.io/

提到 Jenkins 就不得不提另一个持续集成工具——Hudson ， Hudson 由 Sun 公司开发，2010 年 Sun 公司被 Oracle 公司收购， oracle 公司声称对 hudson 拥有商标所有权。 Jenkins是从 Hudson 中分离出来的一个版本，并将继续走 Open Source 的道路。二者现在由不同的团队在维护。

Jenkins 主要用于监视执行重复工作，如建立一个软件项目或工作运行的计划任务。当前 Jenkins 关注以下两个工作。

不断地进行项目的构建/测试软件： 就像 CruiseControl 或 DamageControl。概括地说，Jenkins 提供了一个易于使用的所谓的持续集成系统，使开发人员更容易修改整合到项目中，并使它更容易为用户获得一个新的版本。自动连续生成提高了生产效率。

监控外部运行的作业： 如计划任务作业和 Qrocmail 的工作，即使是那些在远程机器上运行的计划任务。 Jenkins 生成这些日志并且很容易让你注意到错误的出现。

原始封面

01. IntelliJ IDEA 介绍（新用户必看）

Mon, 16 Oct 2017 12:00:11 +0800

介绍

本系列教程介绍

本系列教程从 IntelliJ IDEA 的安装、卸载、软件设置、项目配置等各个方面进行讲解。通过本系列教程的学习，也希望你能爱上 IntelliJ IDEA，爱上它的体贴。同时学完本系列教程对于你学习 JetBrains 公司下的其他产品也有好处，其他产品包括：

PhpStorm 主要用于开发 PHP

RubyMine 主要用于开发 Ruby

PyCharm 主要用于开发 Python

AppCode 主要用于开发 Objective-C / Swift

CLion 主要用于开发 C / C++

WebStorm 主要用于开发 JavaScript、HTML5、CSS3 等前端技术

0xDBE 主要用于开发 SQL

Android Studio 主要用于开发 Android（Google 基于 IntelliJ IDEA 社区版进行迭代所以也姑且算上）

IntelliJ IDEA 介绍

IntelliJ IDEA 官网：https://www.jetbrains.com/idea/

IntelliJ IDEA 在 2015 年 06 月官网主页是这样介绍自己的：

（一）Web Services基本概念

Thu, 21 Sep 2017 02:00:11 +0800

整理这一章资料的过程是比较痛苦的，Web Services 是一项不太容易讲清楚技术，我花不少时间来阅读相关的资料，由于涉及的概念比较多，不同的厂商和专家对这些概念的解释也不完全相同。在概念的选择上我比较倾向于已出版的书籍中的解释。不过，我仍然希望你带怀疑的态度来学习这一章。

SOA

全称: Service-Oriented Architecture，简称 SOA，面向服务架构又称“面向服务的体系结构”。

SOA的提出是在企业计算领域，就是要将紧耦合的系统，划分为面向业务的，粗粒度，松耦合，无状态的服务。服务发布出来供其他服务调用，一组互相依赖的服务就构成了 SOA 架构下的系统。既然称它为一种架构，那么一般认为 SOA 是包含了运行环境，编程模型，架构风格和相关方法论等在内的一整套新的分布式软件系统构造方法和环境，涵盖服务的整个生命周期。

service-architecture.com 网站对 SOA的定义：

SOA 本质上是服务的集合。服务间彼此通信，这种通信可能是简单的数据传送，也可能是两个或更多的服务协调进行某些活动。服务间需要某些方法进行连接。

所谓服务就是精确定义、封装完善、独立于其他服务所处环境和状态的函数。

虽然不同厂商或个人对 SOA 有着不同的理解，但是我们仍然可以从上述的定义中看到 SOA 的几个关键特性：

一种粗粒度、松耦合服务架构，服务之间通过简单、精确定义接口进行通讯，不涉及底层编程接口和通信模型。

对于SOA来说，我们不需要太过较真 SOA 到是一个怎样的架构。只要符合它的定义和规范的软件系统都可以认为是SOA架构。　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

SOA 与 Web Services

早在1996年Gartner就前瞻性地提出了面向服务架构的思想（SOA），SOA 阐述了“对于复杂的企业IT系统，应按照不同的、可重用的粒度划分，将功能相关的一组功能提供者组织在一起为消费者提供服务”，其目的是为了解决企业内部不同IT资源之间无法互联而导致的信息孤岛问题。

直到2000年左右，ESB（Enterprise Service Bus）、Web Services、SOAP 等这类技术的出现，才使得 SOA 渐渐落地。同时，更多的厂商像 IBM、Oracle 等也分别提出基于 SOA 的解决方案或者产品。

因为现在几乎所有的 SOA 应用场合都是和 Web Services 绑定的，所以不免有时候这两个概念混用。不可否认 Web Services 是现在最适合实现 SOA 的技术，SOA 的走红在很大程度上归功于Web Services标准的成熟和应用普及。因为现在大家基本上认同 Web Services 技术在几方面体现了 SOA 的需要：

首先，是基于标准访问的独立功能实体满足了松耦合要求：在 Web Services 中所有的访问都通过 SOAP 访问进行，用WSDL定义的接口封装，通过 UDDI 进行目录查找，可以动态改变一个服务的提供方而无需影响客户端的配置，外界客户端根本不必关心访问服务器端的实现。

appium新手入门（1）—— appium介绍

Fri, 08 Sep 2017 12:24:12 +0800

appium介绍

官方网站

1、特点

appium 是一个自动化测试开源工具，支持 iOS 平台和 Android 平台上的原生应用，web应用和混合应用。

“移动原生应用”是指那些用iOS或者 Android SDK 写的应用（Application简称app）。
“移动web应用”是指使用移动浏览器访问的应用（appium支持iOS上的Safari和Android上的 Chrome）。
“混合应用”是指原生代码封装网页视图——原生代码和 web 内容交互。比如，像 Phonegap，可以帮助开发者使用网页技术开发应用，然后用原生代码封装，这些就是混合应用。

重要的是，appium是一个跨平台的工具：它允许测试人员在不同的平台（iOS，Android）使用同一套API来写自动化测试脚本，这样大大增加了iOS和Android测试套件间代码的复用性。

2、appium与Selenium

appium类库封装了标准Selenium客户端类库，为用户提供所有常见的JSON格式selenium命令以及额外的移动设备控制相关的命令，如多点触控手势和屏幕朝向。

appium客户端类库实现了Mobile JSON Wire Protocol（一个标准协议的官方扩展草稿）和W3C WebDriver spec（一个传输不可预知的自动化协议，该协议定义了MultiAction 接口）的元素。

appium服务端定义了官方协议的扩展，为appium 用户提供了方便的接口来执行各种设备动作，例如在测试过程中安装/卸载App。这就是为什么我们需要appium特定的客户端，而不是通用的Selenium 客户端。当然，appium 客户端类库只是增加了一些功能，而实际上这些功能就是简单的扩展了Selenium 客户端，所以他们仍然可以用来运行通用的Selenium会话。

3、支持多平台、多语言

appium是跨平台的，可以用在OSX，Windows以及Linux桌面系统上运行。

appium选择了Client/Server的设计模式。只要client能够发送http请求给server，那么的话client用什么语言来实现都是可以的，这就是appium及Selenium(WebDriver)如何做到支持多语言的原因；

appium扩展了WebDriver的协议，没有自己重新去实现一套。这样的好处是以前的WebDriver API能够直接被继承过来，以前的Selenium（WebDriver）各种语言的binding都可以拿来就用，省去了为每种语言开发一个client的工作量；

语言/框架	Github地址
Ruby	https://github.com/appium/ruby_lib
Python	https://github.com/appium/python-client
Java	https://github.com/appium/java-client
JavaScript (Node.js)	https://github.com/admc/wd
Objective C	https://github.com/appium/selenium-objective-c
PHP	https://github.com/appium/php-client
C# (.NET)	https://github.com/appium/appium-dotnet-driver
RobotFramework	https://github.com/jollychang/robotframework-appiumlibrary

4、appium工作原理

在安装和介绍appium之前，非常有必要介绍一下appium是如何工作的。

JMeter官方文档：1. 新手入门

Wed, 06 Sep 2017 12:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

注：不知道怎么的翻译的句子保留的英文。

1. 新手入门

1.0 概述

当你使用JMeter的时候一般会遵循以下过程：

1.0.1 创建测试计划

首先，你需要启动JMeter GUI

然后，你可以选择从浏览器或本地应用程序记录应用程序。通过菜单：文件 → Templates… → Recording。

注意，你还可以通过手动生成测试计划，你需要阅读文档并理解上面概念。

你还可以通过下面的方式进行调试：

运行 → Start no pauses
运行 → 启动
验证线程组

和查看结果树的渲染和调试（CSS/JQUERY, JSON, Regexp, XPath）。确保在构建测试计划时遵循最佳实践。

1.0.2 负载测试执行

一旦测试计划就绪，就可以开始负载测试了。第一步是配置运行JMeter的注入器，这对于任何其他负载测试工具包括：

在CPU、内存和网络方面对机器进行正确的调整。
操作系统的优化
Java设置： 确保你安装Java支持的JMeter的最新版本。
正确调整Java堆大小： 默认的JMeter以512MB的堆运行，这可能对你的测试没什么帮助，主要取决于你的测试计划和你想要运行的线程数。

一旦一切就绪，你将使用命令行模式（称为非GUI模式）来运行负载测试。

不要使用GUI模式运行负载测试!

使用非gui模式，你可以生成包含CSV(或XML)结果的文件，并在负载测试结束时生成JMeter生成HTML报告。默认情况下，JMeter将在运行时提供负载测试的摘要。

你还可以使用后端侦听器在测试期间获得实时结果。

1.0.3 负载测试分析

负载测试结果后，可以使用HTML报告来分析负载测试。

1.0.4 让我们开始吧

开始使用JMeter最简单的方法是首先下载最新的产品版本并安装它。该版本包含构建和运行大多数类型的测试所需的所有文件，例如 Web(HTTP / HTTPS)、FTP、JDBC、LDAP、Java、JUnit等。

如果你想要执行JDBC测试，那么你当然需要来数据库供应商JDBC驱动程序。JMeter不包含任何JDBC驱动程序。

（一）认识Git与GitHub

Thu, 31 Aug 2017 06:00:11 +0800

Git的诞生

Linus Torvalds在1991年创建了开源系统Linux，在2002年以前，世界各地的志愿者把源代码文件通过diff的方式发给Linus，然后由Linus本人通过手工方式合并代码！然后，Linux系统已经发展了十年了，代码库之大让Linus很难继续通过手工方式管理了。

于是，Linus Torvalds花了两周时间自己用C写了一个分布式版本控制系统，这就是Git！一个月之内，Linux系统的源码已经由Git管理了！

Git介绍

Git是一个开源的分布式版本控制系统，用以有效、高速地处理从很小到非常大的项目版本管理。相比CVS、SVN等版本控制工具，Git无疑更加优秀，功能更加强大，在项目版本管理中被越来越多的人广泛的使用。但 Git 相对来说比较难学。

使用Git来管理项目有两种方式：

一种是本地部署Git版本管理系统。
另一种是通过在线代码托管。

本地部署Git版本管理系统，需要自己来搭建环境，但项目的提交与更新速度快，更适合较为封闭的项目；使用在线托管最大的好处是在有网络的情况下可以随时随地提交自己的代码，但项目是公开的，当然也可以创建私有项目，大多属于付费服务。

GitHub

GitHub就是基于Git的在线代码托管平台。

GitHub为当前最流行的开源项目托管平台，数以万计优秀的开源项目被托管在GitHub上面。随着越来越多的应用程序转移到云上，Github已经成为了管理软件开发以及发现已有代码的首选方法。对于普通开发人员来讲，其在GitHub上托管的项目已经成为了他的一张个人名片。许多优秀的互联网公司在招聘开发人员时都希望对方能提供个人的GitHub地址。当然，GitHub作为一个开源软件的大宝库，学习和使用它，也会为我们的日常开发带来许多便利。

测试为什么学习Git ？

工作需要

我们工作中需要对项目代码进行管理，我的工作中就先后使用了SVN和Git对项目的版本进行管理。所以，这是测试人员必备技能。

学习需要

你工作中所使用的编程语言的第三方库，大量都在GitHub上面托管，要想安装这些库就会用到Git；另外一些主流的Selenium、Appium开源项目也都是在GitHub上进行维护。

个人名片

将你自己工作中的一些项目和代码放到GitHub上面进行管理。这无疑是对个人能力最好的展示。

原始封面

1.为什么要做接口测试

Wed, 30 Aug 2017 04:41:43 +0800

很多同学反馈现在面试的时候都会问到为什么要做接口测试以及如何做接口测试的问题，那么我们就稍微来科普一下。

本文讨论的接口均是服务级的接口，不是代码级

接口是什么

在讨论为什么要做接口测试之前，我们可以先稍微了解一下接口是什么？

接口可以很不准确的理解成是与资源打交道，这个资源可能是本系统的，也可能是其他系统的。

举个例子，假如我们在开发1个bug管理系统，该系统需要拿到公司的所有开发和测试人员的信息，这样开发和测试人员不用注册都可以登录进去了，这应该很好理解。

那么这些人员的信息储存在哪里呢？一般存储在hr系统里。现在的需求更加明确了，我们要到hr系统中去拿到人员信息，获取hr系统中的人员资源。

怎么拿呢？很多种方式，可以直接把hr系统的数据库拷贝一份放到bug管理系统里，不过这样不好，因为数据的同步会有点麻烦；还可以直接连hr系统的数据库去查，这样也不太好，这样我们就需要了解hr系统的数据存储结构和逻辑，一旦hr系统的数据字段发生改变，bug管理系统也要去该，以便同步。

比较好的做法是，hr系统暴露一些接口，通过这些接口去获取人员信息资源，这样bug系统就不需要关心hr系统的数据存储实现了。

这些接口可能是这样的：

登录的接口，提供人员的用户名和密码，去hr系统中判断该人员是否存在，如果存在验证用户名和密码，如果验证通过就返回1个token，该token就是这个人员的通行证，通过token可以登录到bug管理系统中去；
获取人员信息的接口，返回该人员的职位：测试还是开发，以及用户名，昵称等信息；

综上：接口可以理解成是不同系统或模块之间资源交流方式；

接口测试实际上是黑盒测试

作为黑盒测试，基本的测试思路是通过输入和输出判断被测系统或者对象的逻辑。

获取人员的信息，我需要把人员的用户名传给hr系统接口，这样hr系统的接口会返回给我用户的一些更加具体的信息。这里的输入是用户名，输出是用户的详细信息。

为什么要做接口测试

既然是接口获取和操作资源的方式，而大部分系统和产品中，资源一般都是产品的核心，比如微信核心资源就是通讯录关系链和聊天记录等，因此资源是必测的。

另外接口中大部分的内容是数据，通过数据的对比我们能推测到系统和产品的逻辑，测接口就是测逻辑。

最后接口中的返回相对单纯，不像web页面，html代码中有太多ui的东西，ui最不稳定，变化太快，接口相对稳定一点点，但是里面的干扰信息更少，断言相对容易很多。

接口测试用例怎么写

还是3a原则，这个我以前的回答里有。

A: arrange 初始化测试数据，就是造数据，这里的数据有我们输入的数据，也有目标接口所涉及的资源，比如hr系统中的用户信息，我们必须先有几条人员的详细信息才能去测获取人员信息的接口（当然只是正常的流程，我们有时候还需要清掉数据以便测试资源为空的情况）；
A: act 调用接口，传入输入数据；
A: assert 断言，对返回的资源信息进行断言，比如获取用户信息的接口返回了用户信息之后，我们要判断返回的用户是不是我们想要的那个用户，我们获取的是李雷的信息，接口如果返回韩梅梅，那么接口的逻辑就是不对的；

接口测试笔试题

测试教程网接口测试笔试题

有哪些常见的接口

携程订飞机票，飞机票的信息一般都是通过各大航空公司的接口拿到的；
淘宝的物流信息，一般淘宝的物流信息都是通过各个物流公司的接口拿到的；
第三方微博客户端，个人用户的微博等信息都是通过微博的接口拿到的；

常见的接口测试工具

postman：推荐。基本功能免费。最简单的基于http接口的调试和测试工具;
jmeter：后置处理器配合断言基本上可以满足接口测试需求，就是测试报告要做二次开发
自己撸代码：推荐。配合类似xunit测试框架，基本可以满足一切需求；零基础实现python接口自动化视频教程，一起撸代码吧
soapui: 收费的；
insomnia：强力推荐。postman的弱化版，基本功能免费，重要的是工具代码开源，可以自己改；
paw: 强力推荐。mac上最强，淘宝买个授权好像就百把块钱；

原始封面

appium简明教程（1）——appium和它的哲学世界

Sun, 20 Aug 2017 06:05:07 +0800

什么是appium？

下面这段介绍来自于appium的官网。

Appium is an open-source tool you can use to automate mobile native, mobile web, and mobile hybrid applications on iOS and Android platforms. “Mobile native apps” are those written using the iOS or Android SDKs. “Mobile web apps” are web apps accessed using a mobile browser (Appium supports Safari on iOS and Chrome on Android). “Mobile hybrid apps” have a native wrapper around a “webview” – a native control that enables interaction with web content. Projects like Phonegap, for example, make it easy to build apps using web technologies that are then bundled into a native wrapper – these are hybrid apps.

（一）初始化环境

Sun, 13 Aug 2017 05:24:16 +0800

MacOS

nodejs版本: 6.2.0
selenium-webdriver版本: 3.4.0
chrome版本: 版本 59.0.3071.86（正式版本）64位
chrome driver版本: ChromeDriver 2.30.477690

Windows

TODO

安装nodejs

TODO

安装selenium webdriver

mkdir se
cd se
cnpm install selenium-webdriver

[selenium-webdriver@*] installed at node_modules/.npminstall/selenium-webdriver/3.4.0/selenium-webdriver (20 packages, use 4s, speed 447.48kB/s, json 34.34kB, tarball 1.54MB)

All packages installed (20 packages installed from npm registry, use 4s, speed 446kB/s, json 22(34.34kB), tarball 1.54MB)

安装chrome driver

chrome driver建议通过科学上网的方式下载。

下载地址

下载完成后请将chromedriver.exe(windows)放到系统PATH中

验证chrome driver是否正确安装，请在命令行中输入

chromedriver -h
Usage: chromedriver [OPTIONS]

Options
 --port=PORT port to listen on
 --adb-port=PORT adb server port
 --log-path=FILE write server log to file instead of stderr, increases log level to INFO
 --verbose log verbosely
 --version print the version number and exit
 --silent log nothing
 --url-base base URL path prefix for commands, e.g. wd/url
 --port-server address of server to contact for reserving a port
 --whitelisted-ips comma-separated whitelist of remote IPv4 addresses which are allowed to connect to ChromeDriver

如能看到上述结果则证明安装成功

性能测试基础（一）性能测试分类

Fri, 11 Aug 2017 15:59:11 +0800

关于性能测试有几个名词：性能测试、负载测试、压力测试、并发测试，很多人都是混合使用，或者有时压力测试，有时叫并发测试。这些名词除了非测试人员分不清楚，甚至许多专业测试人员也对这些名词也很模糊。关于这个分类我翻阅了一些资料，解释都比较模糊，并没有给出本质上的区别。只是从不同角度和关注点来解释。我们先来看看这些解释。

#### 性能测试（狭义） ---- 性能测试方法是通过模拟生产运行的业务压力量和使用场景组合，测试系统的性能是否满足生产性能要求。通俗地说，这种方法就是要在特定的运行条件下验证系统的处理能力。

特点：

这种测试方法的主要目的是验证系统是否有系统宣称具有的能力。
这种测试方法要事先了解被测试系统经典场景，并具有确定的性能目标。
这种测试方法要求在已经确定的环境下运行。

也就是说，这种方法是对系统性能已经有了解的前提，并对需求有明确的目标，并在已经确定的环境下进行的。

#### 负载测试 ----

通过在被测系统上不断加压，直到性能指标达到极限，例如“响应时间”超过预定指标或都某种资源已经达到饱和状态。

特点：

这种测试方法的主要目的是找到系统处理能力的极限。
这种测试方法需要在给定的测试环境下进行，通常也需要考虑被测试系统的业务压力量和典型场景、使得测试结果具有业务上的意义。
这种测试方法一般用来了解系统的性能容量，或是配合性能调优来使用。

也就是说，这种方法是对一个系统持续不段的加压，看你在什么时候已经超出“预期要求”或系统崩溃。

#### 压力测试（强度测试） ---

压力测试方法测试系统在一定饱和状态下，例如CPU、内存在饱和使用情况下，系统能够处理的会话能力，以及系统是否会出现错误。

特点：

这种测试方法的主要目的是检查系统处于压力性能下时，应用的表现。
这种测试方法一般通过模拟负载等方法，使得系统的资源使用达到较高的水平。
这种测试方法一般用于测试系统的稳定性。

也就是说，这种测试是让系统处在很大强度的压力之下，看系统是否稳定，哪里会出问题。

并发测试

并发测试通过模拟用户并发访问，测试多用户并发访问同一个应用、同一个模块或者数据记录时是否存在死锁或其者他性能问题。

特点：

这种测试方法的主要目的是发现系统中可能隐藏并发访问时的问题。
这种测试方法主要关注系统可能存在的并发问题，例如系统中的内存泄漏、线程锁和资源争用方面的问题。
这种测试方法可以在开发的各个阶段使用需要相关的测试工具的配合和支持。

也就是说，这种测试关注点是多个用户同时（并发）对一个模块或操作进行加压。

#### 配置测试 --- 配置测试方法通过对被测系统的软\硬件环境的调整，了解各种不同对系统的性能影响的程度，从而找到系统各项资源的最优分配原则。 __特点：__

这种性能测试方法的主要目的是了解各种不同因素对系统性能影响的程度，从而判断出最值得进行的调优操作。
这种性能测试方法一般在对系统性能状况有初步了解后进行。
这种性能测试方法一般用于性能调优和规划能力。

也就是说，这种测试关注点是“微调”，通过对软硬件的不段调整，找出这他们的最佳状态，使系统达到一个最强的状态。

#### 可靠性测试 --- 在给系统加载一定业务压力的情况下，使系统运行一段时间，以此检测系统是否稳定。

特点：

这种性能测试方法的主要目的是验证是否支持长期稳定的运行。
这种性能测试方法需要在压力下持续一段时间的运行。
测试过程中需要关注系统的运行状况。

也就是说，这种测试的关注点是“稳定”，不需要给系统太大的压力，只要系统能够长期处于一个稳定的状态。

除了上面的分类，还有失效性测试，就是系统局部发生问题时，其它模块是否可以正常的运行。这个在极少数情况下进行，这里就不介绍了。

#### 性能测试分类之我见 ---

上面的类分完了，似乎得到不少专家的认同。但我们在做性能测试过程中真的能把它们区分的很清楚么?你能严格区分出你这次的测试到底并发测试还是压力测试。

我中学时练过几年体育，对于一个体育运动员来说，那么多的体育项目，其实，考核他的就两方面：爆发力和耐力。其实，我们在进行性能测试时主要关注的也是这两方面。

爆发力： 拿一个举重选手来说，他的重点在重量上，因为你只要能举起三秒就算你成功了。关键是看你能举起一个什么样的重量。

耐力： 拿一个马拉松运动员来说，你百米速度跑得再快没用。关键是这40公里路程中，最先跑到终点的人才是赢家。

整体协调性： 作为一个教练，在训练运动员时，除了看这个运动员的实际成绩之外，分析运动员的整体协调性，并发现运动员的短板是最关键的。比如一个运行员身体各位部位练得非常强壮，但右臂先天性萎缩。虽然他的最终的跑步成绩不错。但他在跑的过程中，身体有各个部位明显都在分担右臂的不足。右臂影响了整个体能的发挥。

回到性能测试上上，爆发力就是系统能承受的最大压力，没准系统承受的压力很大，但过半个小时之间就挂掉了。耐力就是这个系统长时间处于压力下的稳定性，这系统超级稳定，跑个几十年都不用重启服务器。那么整体协调性就是看系统有没系统瓶颈（短板），并对其进行系统调优。

原始封面

（一）环境安装之Java

Sun, 30 Jul 2017 12:59:11 +0800

### 安装java

点击 JDK8下载，根据自己的平台，选择相应的版本进行下载。

小知识：
Java环境分JDK和JRE ，JDK就是Java Development Kit。简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发
环境和运行环境。JRE是Java Runtime Enviroment是指Java的运行环境，是面向 Java 程序的使用者。

我们以 Windows安装JDK为例，双击下载的JDK，设置安装路径。这里我选择默认安装在__“D:\Program Files\Java\jdk1.8.0_101”__目录下。

下面设置环境变量：

“我的电脑” 右键菜单—>属性—>高级—>环境变量—>系统变量—>新建..

变量名： JAVA_HOME
变量值： D:\Program Files\Java\jdk1.8.0_101
变量名： CALSS_PATH
变量值： .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

找到 path 变量名—>“编辑” 添加：

变量名： PATH
变量值： %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

在Windows命令提示符(cmd)下验证 Java 是否成功：

> java
用法: java [-options] class [args...]
 (执行类)
 或 java [-options] -jar jarfile [args...]
 (执行 jar 文件)
其中选项包括:
 -d32 使用 32 位数据模型 (如果可用)
 -d64 使用 64 位数据模型 (如果可用)
 -client 选择 "client" VM
 -server 选择 "server" VM
 默认 VM 是 client.
......

> javac
用法: javac <options> <source files>
其中, 可能的选项包括:
 -g 生成所有调试信息
 -g:none 不生成任何调试信息
 -g:{lines,vars,source} 只生成某些调试信息
 -nowarn 不生成任何警告
 -verbose 输出有关编译器正在执行的操作的消息
 -deprecation 输出使用已过时的 API 的源位置
 -classpath <路径> 指定查找用户类文件和注释处理程序的位置
.......

java 命令可以运行 class 文件字节码。
javac 命令可以将 Java 源文件编译为 class 字节码文件。

可能读者当前下载的 Java 版本与本书不同，但安装方法是一样的。

（一）软件测试实质

Fri, 28 Jul 2017 12:59:11 +0800

Ron Patton所著的《软件测试》2002年的中文版，已经十五年了，但它对“软件的实质”的解释仍然是经典，这里摘录与大家分享。

实质，哲学中的本质，又称为“实质”是指某一对象或事物本身所必然固有的。说的通俗点也就是说软件测试的本来的面目。

#### 软件缺陷的定义

来看一下Ron Patton 为我们的软件缺陷所下的定义。

1、软件没有实现产品的说明书所描述的功能。

2、软件实现了产品说明书描述不应有的功能。

3、软件执行了产品说明书没讲的操作。

4、软件没有实现产品说明书没讲但应该实现的功能。

5、从软件测试员的角度来看，软件难以理解、不易使用、运行缓慢，或者最终用户认为不对。

为什么一个定义要这么多条来描述？这个“缺陷”的定义有这么复杂么？不，它其实并不复杂，作者只是想更加全面的来给“缺陷”下定义。

#### 完全测试程序的可能性

输入量太大
输出结果太多
软件实现的途径太多
软件说明书没有客观标准。从不同的角度看，软件缺陷的标准不同

以上的“太多”的可能性加在一起，致使测试条件难以确定。

以126邮箱为登录测试为例，其用户长度为50个字符，密码确实不太好计算（因为都是*号），所以这里也按50个字符来计算。

在输入正确用户名的情况下：

1、输入正确的密码名是还否可以登录，

2、那么错误输入0 呢？1呢？2呢？......直到

99999999999999999999999999999999999999999999999999 ，

3、如果密码不是数字，而是字符呢，a 、b、c ... aa、bb 、cc .....

4、如果是大写呢 A 、B、C.... AA 、BB、CC.....

5、如果是大小写呢 Aa、Ab ....

6、如果是小写+数字呢 1a 、1b 、1c ....2a 、2b 、2c.....

7、如果是大写+数字呢 1A 、1B 、1Cc....2A 、2A 、2A.....

8、如果是大写+小写+数字呢 1Aa 、1Bb 、1Cc ....1Aa 、1Bb 、1Cc.....

9、如果有特殊字符呢 @#￥%……&*

10、如果输入字符有空格呢 a b、adbc ee......

11、如果是其它字符+大小写字母+数字呢+空格呢 ！@#&+123AIBKIkklzcb ......

......

12、再换正确的密码，错误的文件名再来一次。

13、用错误的用户名和密码再把上面的情况验证一次。（这样会匹配到所有的用户名密码）

14、什么都不输，直接点击登录

这样穷举下去，就算是计算机也可能需要运行很久。如果觉得某些测试条件是重复的或者是无必要的，而将其剔除，那么就不能称为完全测试。

接口测试面试题1

Tue, 18 Jul 2017 09:30:25 +0800

原题图片

参考答案

1

tps就是吞吐量，transaction per second。

吞吐量下降是可能因为频繁访问redis，而频繁访问redis的原因是参数过多，解决的思路很容易想到: 减少参数。

我们可以把多组参数变成json字符串之类的一个参数，从而达到信息量不减少而参数个数变少的效果。

2

对称加密: 信息交换的双方使用同一个密钥加密解密，就像是用同一把钥匙开一把锁

非对称加密

公开密钥加密（英语：Public-key cryptography），也称为非对称加密（英语：asymmetric cryptography），是密码学的一种算法，它需要两个密钥，一个是公开密钥，另一个是私有密钥；一个用作加密的时候，另一个则用作解密。使用其中一个密钥把明文加密后所得的密文，只能用相对应的另一个密钥才能解密得到原本的明文；甚至连最初用来加密的密钥也不能用作解密。由于加密和解密需要两个不同的密钥，故被称为非对称加密；不同于加密和解密都使用同一个密钥的对称加密。虽然两个密钥在数学上相关，但如果知道了其中一个，并不能凭此计算出另外一个；因此其中一个可以公开，称为公钥，任意向外发布；不公开的密钥为私钥，必须由用户自行严格秘密保管，绝不通过任何途径向任何人提供，也不会透露给要通信的另一方，即使他被信任。

基于公开密钥加密的特性，它还提供数字签名的功能，使电子文件可以得到如同在纸本文件上亲笔签署的效果。

如何测试：略

3

UI与接口测试的协同可以从下面的方向考虑

UI的操作实际上就是用另一种方式调用接口，那么接口有多少种参数组合就要求UI用例要构造多少种操作进行调用
UI操作所需要的数据可以用接口来生成
接口测试可以保证数据和逻辑的准确性，UI测试需要考虑交互和界面展示的逻辑正确性
UI测试需要重视接口调用不成功或者接口异常情况下UI的呈现方式和用户体验
UI中可能会有一些状态的缓存信息（这样就不需要每次频繁调用接口去获取了），比如鉴权信息等，需要重点关注这些缓存的更新策略

4

上下游接口的数据依赖无非就是准备测试数据。

假如一个事务需要顺序调用3个接口，A B C， C依赖于AB，而AB有数据依赖，这时候就需要准备好A和B的数据。

数据一般有两种方式生成

动态方式：假如B依赖A创造的数据，那么每次执行B之前必须执行A去做数据创建
静态方式：独立统一的测试数据库, ABC需要的数据都可以从库里拿到

5

依赖第三方就mock掉，可以自己写mock server

6

依赖登录态，那么每次测试该接口之前都需要调用登录的接口

如果是jwt之类的token based auth的话，每次在调用接口时提供token就可以了

7

不知道，感觉出题者的理解可能有点偏差。

8

修改的接口，也就是update的接口一般只需要传：被更新了的字段 以及被更新实体的主键比如id。

这是开发常识，如果大家研究过jsonapi规格的话，可以直接套用jsonapi的设计进行阐述。

9

swagger文档可以解决这个问题。

10

看不清。

总结

题目涉及到一些开发的知识点，很正常，现在测试面试时一般也会考察一下开发基础。

总的来说题目出的一般，也不算太难，希望这些解答对大家有所帮助。

原始封面

（一）安装selenium

Fri, 30 Jun 2017 12:59:11 +0800

### 安装python

打开 Python官网，找到“Download”, 在其下拉菜单中选择自己的平台（Windows/Mac）,一般的Linux平台已经自带的Python，所以不需要安装，通过打开“终端” ，输入“python”命令来验证。

如果你是第一次接触Python，一定会迷惑Python为什么会提供Python2.x 和 Python3.x两个版本？那么，直接使用Python3.x的最新版本就好了。因为Python2.x预计到2020年不在维护。

如果你是Windows平台用户，会遇到一个版本为什么会提供多种个下载链接。例如：

Python 3.6.1 - 2017-03-21
- Download Windows x86 web-based installer
- Download Windows x86 executable installer
- Download Windows x86 embeddable zip file
- Download Windows x86-64 web-based installer
- Download Windows x86-64 executable installer
- Download Windows x86-64 embeddable zip file
- Download Windows help file

x86 只支持32位的系统； x86-64 支持64位的系统。 web-based 在安装的过程中需要联网；executable 可执行文件(.exe)方式安装；embeddable zip file 嵌入式版本，可以集成到其它应用中。

注意：在安装的过程中需要勾选：“Add Python 3.x to PATH” , 如果没有勾选，需要在安装完成之后，将Python的安装目录（如：C:\Python36）添加到环境变量PATH下面。

打开Windows命令提示符（cmd）/ Linux终端输入：

软件测试分类

Tue, 17 Jun 2025 17:29:15 +0800

软件测试领域名词颇多，许多测试新手容易混淆概念。因为从不同的角度对软件测试有不同的分类方法，所以，这里汇总常见软件测试的相关名词，让读者对软件测试领域有个概括性了解。
#### 根据项目流程阶段划分软件测试

是一个典型的“V”模型软件开发流程，各项软件测试工作是在项目开发流程中循序渐进进行的。下面将介绍各个阶段测试的含义。

单元测试：单元测试（或模块测试）是对程序中的单个子程序或具有独立功能的代码段进行测试的过程。
集成测试：集成测试是在单元测试的基础上，先通过单元模块组装成系统或子系统，再进行测试。重点是检查模块之间的接口是否正确。
系统测试：系统测试是针对整个产品系统进行的测试，验证系统是否满足需求规格的定义，以及软件系统的正确性和性能等是否满足其需求规格的要求。
验收测试：验收测试是部署软件之前的最后一个测试阶段。验收测试的目的是确保软件准备就绪，向软件购买者展示该软件系统能够满足用户的需求。

#### 白盒测试、黑盒测试、灰盒测试

白盒测试与黑盒测试，主要是根据软件测试工作中对软件代码的可见程度进行的划分。这也是软件测试领域中最基本的概念之一。

黑盒测试

黑盒测试，指的是把被测的软件看作一个黑盒子，我们不去关心盒子里面的结构是什么样子的，只关心软件的输入数据和输出结果。它只检查程序呈现给用户的功能是否按照需求规格说明书的规定正常使用、程序是否能接收输入数据并产生正确的输出信息。黑盒测试着眼于程序外部结构，不考虑内部逻辑结构，主要针对软件界面和软件功能进行测试。

白盒测试

白盒测试，指的是把盒子打开，去研究里面的源代码和程序执行结果。它是按照程序内部的结构测试程序，通过测试来检测产品内部动作是否按照设计规格说明书的规定正常进行，检验程序中的每条逻辑路径是否都能按预定要求正确工作。

灰盒测试

灰盒测试介于黑盒测试与白盒测试之间。

可以这样理解，灰盒测试既关注输出对于输入的正确性，同时也关注内部表现。但这种关注不像白盒测试那样详细、完整，它只是通过一些表征性的现象、事件、标志来判断内部的运行状态。有时候输出是正确的，但内部其实已经错误了，这种情况非常多。如果每次都通过白盒测试来操作，效率会很低，因此需要采取灰盒测试的方法。

#### 功能测试与性能测试

从软件的不同测试面可以划分为功能测试与性能测试。

功能测试

功能测试主要检查实际功能是否符合用户的需求，因此测试的大部分工作也是围绕软件的功能进行。设计软件的目的就是满足用户对其功能的需求，如果偏离了这个目的，则任何测试工作都是没有意义的。

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

性能测试

性能测试是通过自动化的测试工具模拟多种正常、峰值以及异常负载条件来对系统的各项性能指标进行的测试。

软件的性能包括很多方面，主要有时间性能和空间性能两种。

时间性能：主要是指软件的一个具体的响应时间。例如一个登录所需要的时间，一个商品交易所需要的时间等。当然，抛开具体的测试环境，来分析一次事务的响应时间是没有任何意义的，它需要在搭建好的一个具体且独立的测试环境下进行。

空间性能：主要指软件运行时所消耗的系统资源，例如硬件资源，CPU、内存、网络带宽消耗等。

#### 手工测试与自动化测试

从对软件测试工作的自动化程度可以划分为手工测试与自动化测试。

手工测试

手工测试就是由测试人员一个一个地去执行测试用例，通过键盘鼠标等输入一些参数，并查看返回结果是否符合预期结果。

手工测试并非专业术语，手工测试通常是指我们在系统测试阶段所进行的功能测试，为了更明显地与自动化测试进行区分，这里使用了手工测试这种说法。

自动化测试

自动化测试是把以人为驱动的测试行为转化为机器执行的一种过程。通常，在设计测试用例并通过评审之后，由测试人员根据测试用例中描述的规则流程一步步执行测试，把得到的实际结果与期望结果进行比较。在此过程中，为了节省人力、时间和硬件资源，提高测试效率，便引入了自动化测试的概念。

自动化测试又可分为：功能自动化测试与性能自动化测试。

功能自动化测试：是把以人为驱动的测试行为转化为机器执行的一种过程。通过测试工具（或框架）录制/编写测试脚本，对软件的功能进行测试，并验证测试结果是否正确，从而代替部分的手工测试工作，达到节约人力成本和时间成本的目的。

性能自动化测试：通过性能工具来模拟成千上万的虚拟用户向系统发送请求，从而验证系统的处理能力。

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

这几种测试出现在软件测试的周期中，既不算具体明确的测试阶段，也不是具体的测试方法。

冒烟测试

是指在对一个新版本进行大规模的系统测试之前，先验证一下软件的基本功能是否实现，是否具备可测性。

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

回归测试

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

回归测试一般是在进行第二轮软件测试时开始的，验证第一轮软件测试中发现的问题是否得到修复。当然，回归也是一个循环的过程，如果回归的问题通不过，则需要开发人员修改后再次进行回归，直到所有问题回归通过为止。

随机测试

是指测试中的所有输入数据都是随机生成的，其目的是模拟用户的真实操作，并发现一些边缘性的错误。

wrk系列教程(2)简单使用

Sat, 02 Mar 2019 02:00:11 +0800

简单起见，建议大家可以先安装python。

在本机启动被测服务

创建一个index.html文件

echo '<h3>It works</h3>' > index.html

index.html里面文件内容很简单，一句话

<h3>It works</h3>'

使用下面命令启动web服务。

python -m SimpleHTTPServer #python2

python -m http.server #python3

预期结果应该是下面这个样子

Serving HTTP on 0.0.0.0 port 8000 ...

验证web服务

新开1个terminal窗口，使用下面命令

curl localhost:8000/index.html

这时候命令行应该显示正确的返回

<h3>It works</h3>

开始压测

使用命令 wrk -c200 -t10 -d30s http://127.0.0.1:8000/index.html

解释一下主要参数

c: connections 表示一共起多少个链接
t: 表示用多少个

结果展示

在我的机器上结果是这个样子的

Running 30s test @ http://127.0.0.1:8000/index.html
 10 threads and 200 connections
 Thread Stats Avg Stdev Max +/- Stdev
 Latency 3.24ms 6.54ms 154.00ms 95.36%
 Req/Sec 167.54 227.05 1.81k 84.83%
 16145 requests in 30.08s, 3.13MB read
 Socket errors: connect 0, read 1208, write 31, timeout 0
Requests/sec: 536.78
Transfer/sec: 106.41KB

对我们来说最重要的1个数据就是倒数第二行的Requests/sec: 536.78。这说明我们测出的服务的QPS是536。

python简明教程: 2. 变量和集合

Wed, 21 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者


# Python 有 print 语句
print "I'm Python. Nice to meet you!" # => I'm Python. Nice to meet you!

# Python3 的时候你应该这么写
print("I'm Python. Nice to meet you!") # => I'm Python. Nice to meet you!

# 从控制台获取输入的简便方法
input_string_var = raw_input(
 "Enter some data: ") # 返回字符串
input_var = input("Enter some data: ") # 把输入作为python代码执行
# 警告: 使用input() 方法时千万请小心谨慎
# 注意: python 3里input()方法被废弃了，并且raw_input()被重命名成了input()

# 给变量赋值之前是不需要声明的
some_var = 5 # 一般约定使用下划线去给变量名分词 lower_case_with_underscores
some_var # => 5

# 访问没有定义的变量会抛出异常
# 在控制流部分可以查看更多关于异常处理的信息
some_other_var # Raises a name error

# if可以作为表达式使用
# 跟 C语言中 '?:' 三元操作符等价
"yahoo!" if 3 > 2 else 2 # => "yahoo!"


li = []
# 你可以定义一个预填充(或者叫非空的列表可能比较好)列表
other_li = [4, 5, 6]

# 使用append方法向列表的尾部添加元素
li.append(1) # li is now [1]
li.append(2) # li is now [1, 2]
li.append(4) # li is now [1, 2, 4]
li.append(3) # li is now [1, 2, 4, 3]
# 使用pop将元素从列表尾部移除
li.pop() # => 3 and li is now [1, 2, 4]
# 重新加回去
li.append(3) # li is now [1, 2, 4, 3] again.

# 访问列表元素跟访问数组元素的语法是相同的
li[0] # => 1
# 使用 = 可以给已经初始化过的索引赋新值
li[0] = 42
li[0] # => 42
li[0] = 1 # 注意: 设置回原先的值
# 访问最后1个元素
li[-1] # => 3

# 访问越界的话会抛出 IndexError
li[4] # Raises an IndexError

# 使用切片(slice)语法可以访问列表中的部分元素.
# (It's a closed/open range for you mathy types.)
li[1:3] # => [2, 4]
# 忽略开头
li[:3] # => [1, 2, 4]
# 忽略结尾
li[2:] # => [4, 3]
# 每隔2个元素选择1个
li[::2] # =>[1, 4]
# 反转列表的拷贝
li[::-1] # => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
# 使用上述的各种组合来创建更加复杂的切片
# li[start:end:step]

# 使用 "del" 来删除任意元素
del li[2] # li is now [1, 2, 3]

# 列表可以相加
li + other_li # => [1, 2, 3, 4, 5, 6]
# 注意: li 和 for other_li 的值没有变化的

# 使用"extend()"来连接列表
# 注意: li的值变化了的
li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]

# 移除第一个满足条件的值
li.remove(2) # li is now [1, 3, 4, 5, 6]
li.remove(2) # 抛出ValueError, 2已经不在列表里了

# 在特定的索引(index)处插入元素
li.insert(1, 2) # li is now [1, 2, 3, 4, 5, 6] again

# 返回第1个满足条件的值的索引
li.index(2) # => 1
li.index(7) # 抛出ValueError，因为7不在列表里

# 用 "in" 来检查元素是否在列表中存在
1 in li # => True

# 用 "len()" 来返回列表的长度
len(li) # => 6

# 元组(Tuples) 跟列表很想，区别是元组是不可变的
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # 抛出TypeError异常

# 你可以在元组上做下面一些的列表操作
len(tup) # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
tup[:2] # => (1, 2)
2 in tup # => True

# You can unpack tuples (or lists) into variables
# 你可以把元组(或列表) unpack成变量
a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3
d, e, f = 4, 5, 6 # 你都可以省略括号
# 如果你不加括号的话，默认情况下会创建元组
g = 4, 5, 6 # => (4, 5, 6)
# 看一下，交换变量的值那是相当容易的
e, d = d, e # d is now 5 and e is now 4

# 字典是用来存储属性名(key)和属性值(value)的
empty_dict = {}
# 这是预填充的字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 用[]来查找属性的值(value)
filled_dict["one"] # => 1

# 用"keys()"来返回所有key的列表
filled_dict.keys() # => ["three", "two", "one"]
# 注意 - 字典key的顺序是不保证的
# 你自己的结果可能会跟上面不同

# "values()"返回所有值(value)的列表
filled_dict.values() # => [3, 2, 1]
# 注意 - 排序问题跟上面的类似

# "items()" 返回所有的键值对(key-value)的元组组成的列表
filled_dicts.items() # => [("one", 1), ("two", 2), ("three", 3)]

# 用"in"来判断某个属性名/某个键是否存在
"one" in filled_dict # => True
1 in filled_dict # => False

# 访问不存在的属性名/键的时候会抛出 KeyError
filled_dict["four"] # KeyError

# 用"get()"方法可以避免 KeyError
filled_dict.get("one") # => 1
filled_dict.get("four") # => None
# get支持当属性名/键不存在的时候返回1个设定的默认值
filled_dict.get("one", 4) # => 1
filled_dict.get("four", 4) # => 4
# 注意: filled_dict.get("four") 仍然是 => None
# (get 并不会设置字典的值)

# 为某个属性名/键赋值跟列表赋值的方式差不多
filled_dict["four"] = 4 # now, filled_dict["four"] => 4

# "setdefault()" 方法在给定的属性名/键不存在的时候会插入具体的值
filled_dict.setdefault("five", 5) # filled_dict["five"] 被设置成 5
filled_dict.setdefault("five", 6) # filled_dict["five"] 仍然是 5

# 集合是存储... 好吧，集合 (跟列表差不多，只是不能有重复的项)
empty_set = set()
# 初始化的时候赋一些值
some_set = set([1, 2, 2, 3, 4]) # some_set 现在等于set([1, 2, 3, 4])

# 顺序是不被保证的, 即使有时候看起来像排过序一样
another_set = set([4, 3, 2, 2, 1]) # another_set 现在是 set([1, 2, 3, 4])

# 从Python 2.7开始, {} 可以被用来声明集合
filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}

# 往集合里添加更多项
filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}

# 用 & 来取交集
other_set = {3, 4, 5, 6}
filled_set & other_set # => {3, 4, 5}

# 用 | 取并集
filled_set | other_set # => {1, 2, 3, 4, 5, 6}

# 用 - 来取差集
{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}

# 用 ^ 取对称差集
{1, 2, 3, 4} ^ {2, 3, 5} # => {1, 4, 5}

# 判断左边的集合是不是右边的超集
{1, 2} >= {1, 2, 3} # => False

# 判断左边的集合是不是右边的子集
{1, 2} <= {1, 2, 3} # => True

# 用in来判断元素在集合中是否存在
2 in filled_set # => True
10 in filled_set # => False

原始封面

（二）Docker安装（Ubuntu）

Mon, 22 Jan 2018 14:55:11 +0800

官方文档：https://docs.docker.com/

Docker 支持多平台的安装（Linux/Windows/OS X）。

因为Docker原生支持Linux，所以，可以直接在Linux上运行，而且在Windows和 OS X 平台则需要借助轻量级的 Linux VM 运行。

Ubuntu安装

在Ubuntu上安装Docker的说明取决于您使用的是Docker企业版（Docker EE）还是Docker社区版（Docker CE）。

参考文档：https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/

使用仓库进行安装

首次在新的主机上安装Docker CE之前，需要设置Docker仓库。之后，你可以从存储库安装和更新Docker。

设置仓库

1、更新 apt 包索引:

$ sudo apt-get update

2、安装软件包，使它允许apt通过HTTPS使用仓库：

$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

3、添加Docker的官方GPG密钥：

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

通过搜索密钥的最后8个字符，确认您现在已经拥有指纹 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 的密钥。

$ sudo apt-key fingerprint 0EBFCD88

pub 4096R/0EBFCD88 2017-02-22
 密钥指纹 = 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88
uid Docker Release (CE deb) <docker@docker.com>
sub 4096R/F273FCD8 2017-02-22

4、使用以下命令来设置 stable 的仓库。即使你想从 __edge __ 或 test 仓库安装构建，也总是需要 stable 的仓库。要添加 __edge __ 或 test 仓库，请在下面的命令中在单词stable之后添加edge或test（或两者）。

（二）Hello world

Wed, 17 Jan 2018 14:45:11 +0800

Hello world

按照管理先用Java写一个 “Hello world” 。

package Base;

public class HelloWrold {

 public static void main(String[] args) {
 System.out.println("Hello World!");
 }
}

main()方法的定义：

main()方法是Java应用程序的入口方法，也就是程序运行时的第一个方法。声明为：public static void main()。

public static：由于JVM在运行这个Java应用程序的时候，首先会调用main()方法，调用时不实例化这个类的对象，而是通过类名直接调用因此需要是限制为public static 即 main() 方法是一个公共的（public）静态（static）方法。
void ： JVM有限制，因此不能有返回值类型为void。
String[] args : main()方法中必须有一个入参，必须是字符串数组（String[]），这个是java的规范。至于字符串数组的名字，是可以随便取的。但根据习惯，这个字符串数组的名字一般和SUN Java规范范例中main参数名保持一致，取名为args。

println()方法输出

因为Java不允许独立于类外的方法存在，所以在命名空间内不存在直接的类函数调用。

System是java.lang中的一个类。 System.out中的out代表了System类中的静态对象PrintStream，println()是PrintStream中的方法。

原始封面

TDD实战（二）“井字游戏” 需求一

Mon, 08 Jan 2018 12:55:11 +0800

保证你会玩“井字游戏” 并理解它的规则。

需求1

先定义边界，以及将棋子放在哪些地方非法。

可将棋子放在3×3棋盘上任何没有棋子的地方。

将需求分成三个测试：

如果棋子放在超出了X轴边界的地方，就引发 RuntimeException 异常。
如果棋子放在超出了Y轴边界的地方，就引发 RuntimeException 异常。
如果棋子放在已经有棋子的地方，就引发 RuntimeException 异常。

测试用例 1

默认你已经会使用 JUnit 单元测试框架了，根据上面的三个测试，我们先来完成第一个。

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;


public class TicTacToeTest {

 @Rule
 public ExpectedException exception = ExpectedException.none();

 private TicTacToe ticTacToe;

 @Before
 public final void before() {
 ticTacToe = new TicTacToe();
 }

 @Test
 public void whenXOutsideBoardThenRuntimeException() {
 exception.expect(RuntimeException.class);
 ticTacToe.play(5, 2);
 }

}

测试调用 TicTacToe 类的 play() 方法，假设第一个参数是 x 轴，第二个参数是 y 轴，前面需求已经规定，棋盘是3×3的规格，所以参数必须不能小于1或大于3。 x 轴为5会引发异常。在 whenXOutsideBoardThenRuntimeException() 测试用例中，预期这被测代码会抛出 RuntimeException异常。

Android测试（二）：Android 测试基础

Wed, 20 Dec 2017 14:50:12 +0800

原文：https://developer.android.com/training/testing/fundamentals.html

用户在不同的级别上与你的应用产生交互。从按下按钮到将信息下载到他们的设备上，因此，你应该在迭代开发应用程序时测试各种用例和交互。

使用迭代开发工作流

当你的应用程序进行扩展时，你可能会发现需要从服务器获取数据，与设备的传感器进行交互，可以还需要访问本地存储，或呈现复杂的用户界面。应用程序的多样性需要一个全面的测试策略。

在迭代开发一个新的特性时，首先需要编写一个新的测试，或者在现有单元测试中添加新的测试例和断言。测试一开始是失败的，因为这个新特性还没有实现。

在设计新功能时，考虑单元测试的设计很重要。对于每个功能单元编写一个相应的单元测试。你的单元测试应该尽可多的涵盖到所有可能与单元的交互，包括标准的交互、无效的输入、以及资源不可用的情况。

图：测试驱动开发：两个周期与迭代过程。

完整的工作流，如上图，包含一系列嵌套的循环迭代。其中长、慢、UI驱动的集成测试，你可以用更短、更快的单元测试驱动开发周期来完成。这一系列循环一直持续到你的应用程序满足每个用例为止。

测试金字塔

图：测试金字塔，显示应该在应用程序的测试套件中包含的三个测试类别。

测试金字塔，如上图所示，说明你的应用程序应该如何包括三种类型的测试：小测试、中测试和大测试。

小测试是你可以在与生产系统隔离的情况下运行的单元测试。它们通常会mock所有主要组件，并在PC上快速运行。
中测试是介于小测试和大测试之间的集成测试。它们集成了几个组件，并在Android模拟器或真实设备上运行。
大测试是通过完成UI工作流来运行的集成和UI测试。它们确保关键的终端用户任务在Android模拟器或真实设备上正常工作。

注：这里测试金字塔的定义是Google针对Android应用的测试划分。不同类型的应用，通过测试金字塔模型进行划层级的划分，以及每层的定义会有所不同。

尽管小测试的速度很快，而且重点突出，可以让您快速处理失败，但它们是低保真和独立的，让你很难相信通过测试的应用是可以正常运行的，所以需要通过大测试进行补足。

由于每个测试类别的不同特性，你的测试工作应该包含测试金字塔的每一层测试。尽管每个类别的测试比例可能因应用程序的使用情况而有所不同，但我们通常建议以下分类：70%的小测试、20%的中等测试和10%的大测试。

小测试

在添加和更改应用程序的功能时，通过创建和编写单元测试来确保这些功能按照预期的来运行。虽然可以在Android模拟器或真实设备中运行单元测试，但是在开发环境中运行单元测试通常会更快、更容易，根据需要添加Stub或mock方法实现与Android系统进行交互。

Robolectric

如果你的应用程序的测试环境要求单元测试与Android框架进行更广泛的交互，那么你可以使用Robolectric。此工具执行测试友好、基于Java 逻辑Stub来模拟Android框架，由社区来维护这些Stub。

Robolectric测试几乎完全符合Android设备上运行测试的完全保真度，但仍比设备测试运行得更快。它还支持Android平台的以下几个方面:

Android 4.1（API等级16）及更高版本
Android Gradle插件2.4及更高版本
组件生命周期
事件循环
所有资源

Robolectric有自己的一套测试API，并引入了一些新概念。有关将Robolectric的API与应用程序的测试相结合的更多信息，请参见该工具的用户指南

Mock对象

你可以通过修改Android.jar版本来运行单元测试，从而来监控应用与之交互的Android框架元素。这个JAR文件不包含任何代码，所以你的应用程序调用Android框架默认会抛出异常。要测试与Android系统交互的代码元素，请使用像Mockito这样的框架来配置模拟对象。

检测单元测试

你也可以在Andorid模拟器或真实设备上运行检测单元测试，而不涉及任何stub或mock框架。因为这种测试形式的执行时间明显比本地单元测试慢，所以最好仅在需要评估应用程序对当前设备硬件的行为时才依赖此方法。

中测试

在开发环境中测试了应用程序的每个单元之后，应验证在模拟器或设备上运行时组件的行为是否正确。中等测试允许您完成这部分的开发过程。如果某些应用程序的组件依赖于物理硬件，则这些测试对于创建和运行尤其重要。

中等测试你的应用程序如何协调多个单元，但它们不测试完整的应用程序。中等测试的用例包括服务测试、集成测试以及mock外部依赖性行为的UI测试。

通常情况下，最好在Android模拟器或Firebase测试实验室等基于云服务上测试应用程序，而不是在真实设备上测试应用程序，因为你可以更轻松，快速地测试多种屏幕大小和硬件配置组合。

大测试

尽管测试应用程序中的每一层的功能是非常重要的，但是测试涉及整个堆栈的常见工作流和用例（从UI到业务逻辑到数据层）同样重要。

如果您的应用程序足够小，则可能只需要一套大型测试来评估你的应用程序。否则，你应该根据团队所有权，垂直功能或用户目标来划分你的大型测试套件。

对于你所编写的每一个大型的基于工作流程的测试，你还应该编写中测试来检查工作流中包含的每个UI组件的功能。通过这种方式，即使在最初的几个步骤中，相应的大型测试也会失败了，你的测试套件仍然可以在关键用户操作的每一步中继续识别潜在的问题。

AndroidJUnitRunner类定义了一个基于JUnit框架的测试运行器，它允许你在Android设备上运行JUnit 3或JUnit 4样式的测试类。便于将测试包和应用程序加载到真实设备或Android模拟器上，运行测试并报告结果。

Fiddler（二）主界面介绍

Tue, 19 Dec 2017 13:59:11 +0800

在开始Fiddler工具之前，请先学习 HTTP基础

Fiddler主界面

Fiddler 工具界面如上图。

请求列表（左侧窗口）

显示Fiddler 工具拦截的 HTTP/HTTPS 请求。

# 显示资源类型与编号。

Result 表示HTTP返回的状态码。如 200、302、500等。
Protocol 表示请求的协议：HTTP/HTTPS
Host 请求的IP或网址。
URL 请求的路径。
Body 请求资源的大小。
Caching 请求的缓存过期时间或者缓存控制值。
Content-Type 请求响应的类型。
Process 发送此请求的进程：进程ID。
Comments 允许用户为此回话添加备注。
Custom 允许用户设置自定义值。

Statistics（右则窗Statistics标签）

Statistics 显示关于HTTP请求的性能以及数据分析。

Inspectors （右则窗Inspectors标签）

Inspectors 是用于查看会话的内容，上半部分是请求的内容，下半部分是响应的内容。

搭建开发环境

Sun, 17 Dec 2017 02:52:34 +0800

开发环境介绍

我们使用python来实现最简单的爬虫。

使用python的requests库来发起http请求并获取目标站点的html代码。
使用python的BeautifulSoup库来解析html，从html中提取感兴趣的内容。

Requests教程

大家可以在测试教程网requests教程中找到requests库的一些典型用法。

环境搭建

安装python3，可以参考这里
安装requests，可以参考这里
安装BeautifulSoup，可以参考这里

作者使用软件版本

我的电脑上环境是这样

python: 3.5.2
requests: 2.13.0
beautifulsoup4: 4.6.0

不需要与我的版本保持完全一致，只需要大于等于我使用的版本就可以了

原始封面

（二）验证某些行为

Sat, 25 Nov 2017 12:55:11 +0800

跟着我们的示例来mock 一个List,因为大家都知道它的接口（例如add(),get(), clear()）。不要mock一个真实的List类型,使用一个真实的实例来替代。

验证某些行为

例子：


import org.junit.Test;

import java.util.List;

 // 静态导入会使代码更简洁
import static org.mockito.Mockito.*;



public class MockitoDemo {

 @Test
 public void verify_behaviour() {
 // mock creation 创建mock对象
 List mockedList = mock(List.class);

 //using mock object 使用mock对象
 mockedList.add("one");
 mockedList.clear();

 //verification 验证
 verify(mockedList).add("one");
 verify(mockedList).clear();
 }

}

一旦mock对象被创建了，mock对象会记住所有的交互。然后你就可能选择性的验证你感兴趣的交互。

原始封面

（二）Maven 安装

Sat, 25 Nov 2017 12:50:11 +0800

准备工作

JDK ： Java 开发程序所使用的环境。

IntelliJ IDEA ： Java 开发程序所使用的 IDE。

Maven ：下载地址 http://maven.apache.org/download.cgi

环境配置

将 Maven 下载到本地解压，这里以下载当前最新版本（apache-maven-3.5.0-bin.zip）为例，解压到得到 apache-maven-3.5.0 目录。

下面设置环境变量：

“此电脑” 右键菜单—>属性—>高级—>环境变量—>系统变量—>新建..

变量名： MAVEN_HOME

变量值： D:\java\apache-maven-3.5.0

找到 path 变量名—>“编辑” 添加：

变量名： PATH

变量值： %MAVEN_HOME%\bin;

验证 Maven 环境是否配置成功

原始封面

（二）第一个测试用例

Sat, 25 Nov 2017 12:50:11 +0800

第一个测试用例

通过 IntelliJ IDEA 创建 FirstTest 测试类。编写如下代码：


import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;


public class FirstTest {

 @Test
 public void testCase(){
 assertEquals(2+2, 4);
 }
}

通过 @Test 注解一个方法为测试用例。
通过 assertEquals() 方法来断言两个数是否相等。

运行测试：

===============================================
Default Suite
Total tests run: 1, Failures: 0, Skips: 0
===============================================

我们先感官上对TestNG使用有一个初步认识。

原始封面

requests如何发送get请求?

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

使用requests发送请求其实非常简单。

首先导入Requests模块

>>> import requests

下面试着去发送具体的请求，比如获取github的timeline信息

r = requests.get('https://api.github.com/events')

r是requests的响应(Response)对象，我们可以从r里面获取各种信息，比如获取响应的内容print(r.text)

原始封面

（二）JUnit 安装

Mon, 13 Nov 2017 12:55:11 +0800

Junit目前分两个版本，Junit4 和 Junit5 , 本系列教程打算从 Junit4 开始介绍，最后，再介绍 Junit5 有哪些新特性。

IntelliJ IDEA 安装 Junit

Java 开发的同学，推荐使用 IntelliJ IDEA，推荐阅读《IntelliJ IDEA 教程》。

1、下载 junit-4.12.jar 文件：https://github.com/junit-team/junit4/releases

2、打开 IntelliJ IDEA ，菜单栏：File菜单 –> Porject Structure 选项 –> Dependencies 标签 –> 点击 “+” 号 –> Library… –> Java 。 选择下载的 junit-4.12.jar 进行添加。

3、以同样的方式下载和导入 hamcrest： https://github.com/hamcrest/JavaHamcrest/releases ,否则，你将无法运行 Junit 单元测试。

Maven 安装 Junit

相比较而言，Maven 的安装要简单很多，打开你 Maven 项目中的 pom.xml 文件，添加如下配置：

2. 基本用法

Wed, 08 Nov 2017 06:23:31 +0800

我们通过最简单的例子来看一下unittest的基本用法，下面的代码测试了3个python字符串方法，基本上满足了大部分情况下的测试需求

import unittest

class TestStringMethods(unittest.TestCase):

 def test_upper(self):
 self.assertEqual('foo'.upper(), 'FOO')

 def test_isupper(self):
 self.assertTrue('FOO'.isupper())
 self.assertFalse('Foo'.isupper())

 def test_split(self):
 s = 'hello world'
 self.assertEqual(s.split(), ['hello', 'world'])
 # check that s.split fails when the separator is not a string
 with self.assertRaises(TypeError):
 s.split(2)

if __name__ == '__main__':
 unittest.main()

解释一下关键点

可以通过继承unittest.TestCase类来定义我们自己的测试用例，1个测试用例类下面可以有多个测试方法(test)或者叫做测试点
记住这个套路：测试用例中方法名以test开头的方法才是测试方法，比如上面的例子里定义了3个以test开头的方法，分别是test_upper，test_isupper和test_split。非测试方法是不会被test runner执行的
断言是测试用例的核心。我们使用assertEqual()来判断预期结果，用assertTrue()和assertFalse来做是非判断，以及用assertRaises()来判断预期的异常是否有被抛出。这些unittest提供的以assert开头的方法就是断言，一般情况下,每个测试方法里都必须有断言
最后, unittest.main提供了最简单的运行用例的方式。当我们从命令行运行上面的代码时，我们可以看到如下的输出

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

除了使用unittest.main，还有其他的方式可以运行测试用例，比如把最后2行替换为

suite = unittest.TestLoader().loadTestsFromTestCase(TestStringMethods)
unittest.TextTestRunner(verbosity=2).run(suite)

运行用例，结果将会如下所示

2. #及注释

Mon, 06 Nov 2017 08:17:22 +0800

背景

注释是代码中非常重要的部分，一般来说注释的作用有下面一些

告诉你这段代码中实现了些什么，帮助你或其他阅读代码的人去理解代码
暂时让某段代码失效

代码实现

新建名为report_with_comments.py的文本文件，用文本编辑器打开，输入如下内容:

# 打印出本次测试的测试结果

print('本次测试功能点5个') # 本次回归测试涉及到多个功能点
print('测试用例20个') # 这些功能点一共编写了多少用例
print('共执行测试用例20个') # 回归了多少个
print('共发现缺陷0个') # 这些用例总用发现了多少个缺陷
print('用例通过率100%') # 通过率计算公式: 执行成功的用例/用例总数

# 结束打印
print('回归通过')

注意: 照着上面代码敲一遍，敲完以后检查一遍，因为对于新手来说，一次性就敲准确不那么容易。

运行

在命令行中使用下面的命令去执行代码

python report_with_comments.py

你应该可以看到

如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

本次测试功能点5个
测试用例20个
共执行测试用例20个
共发现缺陷0个
用例通过率100%
回归通过

动手时间

自己搞清楚#的作用是什么
把上面的代码大声读出来，没错，跟读课文一样读出来，看能不能找到自己代码中的错误
把上面的代码反过来阅读一遍，这次就不用读出声来了，看能不能发现更多的错误

常见问题

print('Hi, # there')中的"#“为什么没有注释的作用？因为当”#“在字符串中(字符串就是用一对单引号或双引号包围的文本或文字)的时候，”#“就不再是注释的符号，而是只是一个普通字符，会被原原本本打印出来
如何注释多行代码呢？ 在每一行前面都加个”#“号
为什么我需要倒过来读代码？ 这可以让你换个角度看自己写的东西，更容易发现代码中的错误

原始封面

2.运行多个文件

Wed, 01 Nov 2017 07:22:42 +0800

背景

在现实的测试活动中，我们经常会定义多个用例文件，用来实现业务逻辑或其他逻辑上用例的物理分隔，比如

login_test.py # 登录相关功能的测试用例
cart_test.py # 购物车相关功能的测试用例
checkout_test.py # 结算相关功能的用例
order_test.py # 订单相关功能的用例

使用pytest可以很方便的执行批量执行一组文件中定义的用例。

潜规则

在批量执行用例之前，我们需要了解一下pytest的潜规则，注意，由于pytest可以支持丰富的定制选项，下面的潜规则是在没有定制的默认情况下的缺省规则

pytest会找当前以及递查找子文件夹下面所有的test_*.py或*_test.py的文件，把其当作测试文件
在这些文件里，pytest会收集下面的一些函数或方法，当作测试用例
- 不在类定义中的以test_开头的函数或方法
- 在以Test开头的类中(不能包含__init__方法)，以test_开头的方法
pytest也支持unittest模式的用例定义

实例

新建test_calc.py文件，与上一节的test_quick_start.py放在同一文件夹下，敲入下面的内容

def add(x, y):
 return x + y

def test_add():
 assert add(1, 0) == 1
 assert add(1, 1) == 2
 assert add(1, 99) == 100

现在当前文件夹下应该有2个文件

test_calc.py
test_quick_start.py

运行

在当前文件夹敲下面的命令

pytest

结果大致应该如下所示

$ pytest
========================================================================= test session starts =========================================================================
platform darwin -- Python 2.7.12, pytest-3.2.3, py-1.4.34, pluggy-0.4.0
rootdir: /Users/easonhan/code/testclass.net/src/pytest, inifile:
collected 2 items

test_calc.py .
test_quick_start.py .

====================================================================== 2 passed in 0.01 seconds =======================================================================

总结

上面的例子里

所有以test_开头的py文件都被当成了测试文件
所有测试文件中以test开头的方法被当成了测试用例执行

原始封面

2. BasePage

Sat, 28 Oct 2017 06:55:26 +0800

页面类是Page Object设计模式的核心。在使用webium创建页面类的时候，必须继承webium.base_page.BasePage

from webium import BasePage

class MyPage(BasePage):
 pass

url

如果页面的url是固定的，那么可以在__init__方法中指定它，然后你就可以使用open()方法来跳转到该页面。

url也可以被定义成是类的静态属性。

from webium import BasePage

class PageWithUrl(BasePage):
 def __init__(self):
 super(PageWithUrl, self).__init__(url='http://www.testclass.net/')

class AnotherPageWithUrl(BasePage):
 url = 'http://www.itest.info'

if __name__ == '__main__':
 page = PageWithUrl()
 page.open()

 itest = AnotherPageWithUrl()
 itest.open()

driver

页面类必须持有WebDriver的实例以便操控浏览器。默认情况下，webium会使用webium.settings.driver_class来创建WebDriver实例。如果你需要获取driver的实例，你可以使用webium.driver.get_driver()来达到目的。

在实例化页面类时，我们也可以通过driver参数来显示传入WebDriver实例。

from selenium.webdriver import Firefox
from webium import BasePage

class DriverHandlingPage(BasePage):
 def __init__(self, *args, **kwargs):
 super(DriverHandlingPage, self).__init__(url='http://testclass.net/', *args, **kwargs)


if __name__ == '__main__':
 my_driver = Firefox()
 page = DriverHandlingPage(driver=my_driver)
 page.open()
 print('Page title: ' + my_driver.title)
 my_driver.quit()

原始封面

收藏清单:Java自动化测试工具汇总

Thu, 26 Oct 2017 08:19:06 +0800

xUnit frameworks 单元测试框架

JUnit - 常用的测试框架
TestNG - 测试框架
- Test Data Supplier - TestNG DataProvider封装，让数据的生成更加灵活

TDD \ ATDD \ BDD

工具
- JBehave - Behaviour-Driven Development (BDD)测试框架. BDD是从 test-driven development (TDD) 和 acceptance-test演进而来, 让用例的编写对新手更加友好和直觉化
- Cucumber-JVM - 纯 java的Cucumber实现,支持大部分流行的jvm语言
- JGiven - 开发者友好且实用的BDD工具. 开发者使用纯java及流利API编写测试场景, JGiven负责生成领域专家可读的报告
- easyb - Java平台的BDD框架. 通过使用Domain Specific Language(DSL), easyb致力于让文档可读可执行
- robotframework - 最有名的acceptance test-driven development (ATDD)测试框架
  - awesome-robotframework - 各种rf的扩展库
- Spectrum - BDD-style test runner，支持Java 8. 灵感来自于Jasmine, RSpec和Cucumber.
- cucumber-report-db - 把Cucumber的结果存到数据库里，并且提供测试报告

Model-Based Testing

GraphWalker - Model-Based测试框架. 这个工具可以从 graphml, dot 或 json文件中读取model，然后自动创建测试用例

Code analysis and coverage 代码扫描和代码覆盖率

SonarQube - 管理代码质量的开源工具
Gradle Quality Plugin - 静态代码分析工具，支持Java和Groovy，使用 Checkstyle, PMD, FindBugs 和CodeNarc. 插件使用了统一的控制台输出并简化了开发者的工作流: 查看不规范的错误时只需要留意控制台就好，并且控制台输出的体验跟java编译错误的输入体验一致
Qulice - Qulice是Java项目的代码扫描和质量控制工具. 包含了最好的静态代码扫描工具和预配置选项。你不需要单独再对这些工具进行配置了。
JaCoCo - JaCoCo是免费的代码覆盖率统计工具，应该也是应用最广泛的覆盖率工具了。

Web UI test automation web ui自动化工具

libraries
- Selenium - 浏览器自动化工具
- SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持windows/linux/mac系统
frameworks and wrappers 框架及封装
- Selenide - 简洁的Selenium封装,让 UI用例的编写更容易
- Selenified - 开源的测试框架，目的是让selenium测试更加简单,提供了简单的接口去添加测试报告，错误处理以及线程安全的运行模式。可以运行在本机或云端(Grid or SauceLabs).
- Serenity BDD (Thucydides) - 创新的开源库，让你可以更高效的编写用户验收用例, 并可以根据用例去生成项目文档及测试报告
- htmlelements - 让web测试时元素交互更加简单的java库
- atlassian-selenium - 让开发者可以更高效的编写Selenium/WebDriver功能测试的开源库
- stevia - Persado出品的开源自动化测试框架
- darcy - 开源的测试框架，支持java 8，提供了具有表意性以及使用简单的API
- Satisfy - 基于Thucydides和Jbehave的开源测试框架。支持WebUI, SOAP, REST, emails, files，并支持创建随机数据，开箱即用
- JDI UI Test Automation Framework - UI自动化测试框架。扩展了Page Object设计模式，并加入了一些常用的元素
- Geb Framework - 基于groovy自动化测试框架。专为Webdriver Page Object设计模式以及Spock Framework(BDD)的集成而设计。
- FluentLenium - FluentLenium可以帮助你写出可读性好, 可重用, 可靠且灵活的Web UI功能测试用例. FluentLenium 提供了为Selenium实现的流利api,并为selenium用户的一些常见问题提供了解决方案。
- Selion - 基于TestNG和Selenium提供了一系列的功能，让你可以在短时间内搞定webdriver. 支持web和移动端测试
extensions 扩展
- BrowserMob Proxy -从浏览器获取性能数据的简单工具, 一般跟自动化工具，比如Selenium和Watir配合使用
- Selenium-Grid-Extras - 让Selenium Grid 节点的管理更加简单，并通过清理测试环境的方式让节点更加稳定
- Selenium Grid Extensions - 扩展了Selenium grid，以及可以在执行selenium用例的同时执行Sikuli用例
- Selenium Grid Router 轻量级的server，作用是把Selenium Wedriver的请求分发到多个Selenium hub。
- Docker Selenium Grid - 提供了native的视频录制功能，支持Selenium Grid，最初被设计为跟docker-selenium一同使用。
- Video Recorder Java - 使用自动化测试用例来录制视频的java库
- Zalenium - 提供一次性的灵活的Docker-based Selenium Grid视频录制功能, 支持实时预览和online/offline控制面板。
- SikuliFactory - 为SikuliX提供了PageFactory实现。
- Mailosaur - 邮件自动化测试工具，基于Mailosaur。

Mobile test automation 移动自动化测试

Appium - 开源的自动化测试框架，可以测试native/hybrid/mobile web应用。核心是基于webdriver协议进行了扩展
Calabash - 跨平台的自动化测试框架，支持Android和iOS的原生应用以及hybrid应用。 Calabash的语法非常容易理解，甚至可以让非技术人员编写和执行基于上述平台的自动化测试用例。
Robotium - 安卓自动化测试框架，支持原生及hybrid应用. Robotium让我们可以非常方便的编写强大和稳定的黑盒UI测试用例。有了Robotium的支持, 测试开发工程师可以编写安卓应用的功能用例系统用例以及用户验收用例。
UIautomator - 提供了高效的测试UI的方式。可以创建支持真机及模拟器运行的自动化测试用例，并包含了可以查看和分析安卓UI的viewer。
Espresso - 比较新的开源自动化测试框架, 让开发者和测试人员都可以编写UI用例。 Espresso的api简单且易学，你可以非常快的使用这个框架上手安卓自动化测试

API test automation 接口自动化测试

Karate-DSL - Karate是BDD风格的使用javascript实现的测试框架。可以让你调用任何web-service类型的接口并对响应进行断言。

Windows UI test automation windows ui自动化测试工具

SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持多操作系统
Winium.Desktop - 测试Windows应用(主要是基于WinForms和WPF平台)的自动化测试工具. 实现了Selenium Remote WebDriver协议

Unix \ Linux UI test automation Unix \ Linux ui自动化工具

SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持多操作系统

MacOS UI test automation mac ui自动化工具

SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持多操作系统

Server side test automation 服务端自动化测试工具

Citrus - Javas实现的测试框架，支持企业级SOA应用的e2e服务测试，支持 HTTP, JMS, TCP/IP, FTP, SOAP协议，以及XML和JSON.

原始封面

（二）Jenkins 环境搭建

Mon, 16 Oct 2017 14:00:11 +0800

Jenkins 是基于Java开发的一种持续集成工具，所以，Jenkins需要Java环境。关于Java环境的配置我们在第9章使用Selenium Grid 时已经作了介绍，这里不在讲解。

安装 Tomcat

Tomcat是针对Java的一个开源中间件服务器（容器），基于Java Web的项目需要借助Tomcat 才能运行起来。

Tomcat官方网站：http://tomcat.apache.org/ ，打开后首页如图2.1所示

图2.1 下载Tomcat

单击页面左侧Tomcat 版本进行下载，对下载的压缩包进行解压，目录结构如图2.2所示。图2.2 webapps目录用于web项目通常将需要运行的应用放到webapps/目录下，进入bin/目录下，双击startup.bat，启动Tomcat服务器。

安装 Jenkins

Jenkins官方网站：https://jenkins.io/ ，打开后首页如图2.3所示。

图2.3 下载Jenkins

点击“Download” 链接进入下载页面，根据自己的系统选择对应的 Jenkins 版本进行下载。

下载完成，双击进行安装，如图2.4所示。

图2.4 双击Jenkins安装

单击“next”按钮，我们直接将其安装到Tomcat的 webapps 目录下，如图2.5所示。一定要选择TomCat 的 webapps 目录。

（二）Locust 安装

Mon, 16 Oct 2017 13:00:11 +0800

Locust 是基于 Python 语言的一个性能测试库，如果要想使用它来做性能测试必须要先安装 Python 。

Python安装，参考

#### Locust 安装 ---- 方式一：通过 pip 命令安装

> pip install locust

Collecting locust
 Downloading locust-0.8.tar.gz (225kB)
 59% |███████████████████ | 133kB 199kB/s eta 0:00:0
 63% |████████████████████▍ | 143kB 304kB/s eta 0:00:
 68% |█████████████████████▉ | 153kB 358kB/s eta 0:0
 72% |███████████████████████▎ | 163kB 355kB/s eta 0:
 77% |████████████████████████▊ | 174kB 421kB/s eta
 81% |██████████████████████████▏ | 184kB 449kB/s eta
 86% |███████████████████████████▋ | 194kB 439kB/s e
 90% |█████████████████████████████ | 204kB 487kB/s
 95% |██████████████████████████████▌ | 215kB 492kB/s
 99% |████████████████████████████████| 225kB 487kB
 100% |████████████████████████████████| 235kB 417k

 ....

方式二：GitHub下载安装

（二）Web Services技术之SOAP

Thu, 21 Sep 2017 01:00:11 +0800

__早前的 Web Services 技术由 SOAP、WSDL 和 UDDI 就构成。__

SOAP

Simple Object Access Protocol，简称 SOAP，简单对象访问协议。

SOAP 是基于 XML 在分散或分布式的环境中交换信息的简单的协议。允许服务提供者和服务客户经过防火墙在互联网上进行通信。

SOAP 的设计是为了在一个松散的、分布的环境中使用 XML 对等地交换结构化的和类型化的信息提供了一个简单且轻量级的机制。

XML是可以扩展标记语言。

<bookstore>
 <book category="COOKING">
 <title lang="en">Everyday Italian</title>
 <author>Giada De Laurentiis</author>
 <year>2005</year>
 <price>30.00</price>
 </book>
</bookstore>

SOAP 消息的基本结构

<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">

 <soap:Header>
 ...
 ...
 </soap:Header>

 <soap:Body>
 ...
 ...
 <soap:Fault>
 ...
 ...
 </soap:Fault>
 </soap:Body>

</soap:Envelope>

当 SOAP 消息真正需要在网络上传输的时候，SOAP 消息能够与不同的底层传输协议进行绑定，同时，SOAP 消息也可以在很多种消息传输模式中使用。包括超文本传输协议（HTTP），简单邮件传输协议（SMTP），多用途网际邮件扩充协议（MIME）。它还支持从消息系统到远程过程调用协议（RPC）等大量的应用程序。

当然，大多的情况还是绑定在 HTTP 协议上面传输。所以，这就导致许多人认为 SOAP 就是 HTTP + XML，或者认为 SOAP 是 HTTP 的 POST 请求的一个专用版本，遵循一种特殊的 XML 消息格式。虽然，我们看到的情况确实如此，但显然这些观点对SOAP的解释是错误和片面的。

appium新手入门（2）—— 安装 Android SDK

Thu, 07 Sep 2017 12:24:12 +0800

注明： 理论上这一章不是必须的，如果你不想使用 Android 模拟器运行测试的话可以跳过，不过，建议安装；原生 Android 好折腾！关键是它自带的一些工具是你做 appium 测试必须要用的！

安装Android SDK

Android SDK（Software Development Kit，软件开发工具包）提供了 Android API 库和开发工具构建，测试和调试应用程序。简单来讲，Android SDK 可以看做用于开发和运行 Android 应用的一个软件。

1、下载Android SDK

我在官网上没有找到单独 Android SDK 的下载链接，官方推荐下载包含 Android SDK 的 Android Studio。

Android Studio & Android SDK 下载地址：https://developer.android.com/studio/index.html?hl=zh-cn

拖到页面底部，你将找到下载链接，根据自己的平台选择对应的链接下载。

一方面是包含 Android SDK 的 Android Studio 的安装包很大。另一方面它们二者也不是强关联的。因为 Appium也会用到 Android SDK，而 Android Studio 也可以调用真机来运行 Android程序。

所以，Android SDK 下载地址（才是我们想要的）：

http://tools.android-studio.org/index.php/sdk

你可以通过别的网站进行下载，身为IT从业人员，如何利用搜索工具和科学上网工具是你的必备技能。

将下载的 Android SDK 解压，将得到如下目录。

（二）GitHub注册与Git安装

Thu, 31 Aug 2017 03:00:11 +0800

注册GitHub

GitHub官方地址：https://github.com。

在浏览器中打开GitHub网址，通过首页进行注册，如下图所示。

安装Git

Git官方下载地址：http://git-scm.com/download/。

Git支持多平台（Mac OS X/Windows/Linux/Solaris）,读者可根据自己的平台选择相应的版本下载。

Linux 各版本下安装Git：

 Debian/Ubuntu $ apt-get install git-core

 Fedora $ yum install git

 Gentoo $ emerge --ask --verbose dev-vcs/git

 Arch Linux $ pacman -S git

下载并安装完成后，我们通常在Mac OSX及Linux平台下用终端工具(Terminal)来使用Git，而在Windows平台下用Git Bash工具，如下图所示。

建立链接

本地Git与GitHub服务器之间保持通信时，我们使用SSH key认证方式来保证通信安全，所以在使用GitHub前你必须先建创自已的SSH key。我们后续操作以Windows为例，打开Git Bash，如下图所示。

2.最简单的接口长什么样

Tue, 29 Aug 2017 04:41:43 +0800

接口测试由浅入深的学习才可以尽量减少挫败感，避免从入门到放弃的悲剧。

从入门到放弃其实最可惜，毕竟花了那么多时间去学习，最后放弃掉，花费掉的青春就一去不复返了。

获取资源的接口

我们先来看一下获取资源的接口。

v2ex是一个讨论区，也就是大家常说的论坛，这是一个小众的讨论区，基本上只有程序员光顾。

v2ex里有很多的节点，节点可以理解成是讨论板块，比如这个板块就是讨论python技术的。

v2ex提供了一些接口，可以让我们去获取v2ex站点的一些资源，比如讨论区的信息，热门帖子等，这很符合互联网的分享精神。

v2ex的api描述页面在这里, 文档相对简洁，基本上是给看得懂的人看的。

我们仔细研究一下获取节点信息的接口。这个接口可以获取指定节点的名字，简介，URL 及头像图片的地址。

下面是这个接口的具体描述

获得指定节点的名字，简介，URL 及头像图片的地址。

https://www.v2ex.com/api/nodes/show.json

Method: GET
Authentication: None
接受参数：

name: 节点名（V2EX 的节点名全是半角英文或者数字）
例如：

https://www.v2ex.com/api/nodes/show.json?name=python

我们从这个接口文档里可以获得哪些信息呢？换一句话说，我们能不能通过接口文档去了解这个接口是做什么的呢？

接口分析

从上面的描述里，我们可以得到下面一些信息

接口的协议：https协议，也就是更安全版本的http协议；
请求的方法：http协议里定义了一些请求的方法或者叫动词，这些方法和动词可以进一步定义请求的目的，比如是获取资源还是创建资源等；上面的例子里，请求方法是GET;
请求参数：http协议里规定了请求的时候可以传递一些参数给服务端，这些参数可以更加具体的描述资源，比如获取多少个资源，这个资源的名字是什么。上面的例子里，我们可以传递name参数指定资源的名称，比如获取名字叫python的资源，这里资源就是节点；
鉴权：简单来说，就是要不要登录，很显然，上面的接口是不需要登录的

合起来，我们应该可以得到这样的信息：

当我们发送:https://www.v2ex.com/api/nodes/show.json?name=python，这个http的get请求给服务器之后，服务器应该返回相应的资源，那么这时候就需要探讨一下

什么是请求: 视频在这里
什么是响应: 视频在这里

如何查看接口的返回

我们现在已经知道了这个接口的情况了，如何查看接口的返回呢？

我们可以使用一些辅助工具帮助我们进行接口的调用，查看接口返回，最简单的跨平台调试工具推荐使用postman

原始封面

JMeter官方文档：2. 创建测试计划

Thu, 24 Aug 2017 12:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

2.构建测试计划

测试计划描述了当程序运行起来时JMeter会执行的一系列步骤，一个完整的测试计划会由以几部分组成，包括一个或多个线程组、逻辑控制器、示例生成控制器、侦听器、定时器、断言、和配置元素组成。

2.1 添加和删除元素

我们可以通过下面两种方式添加元素到测试计划，一种是右键点击树上的元素，从“添加”列表中选择一个新元素；或者也可以通过选择菜单栏“文件”–“合并”或“打开”选项从文件中加载元素。

确保元素是被选中的，右键单击元素，选择“删除”选项可以将元素移除.

2.2 加载和保存元素

通过文件加载元素，右键选择向其中添加加载元素的树元素，选择“合并”选项选择元素保存的文件，JMeter会将元素合并到树中去。

右键一个元素并选择“选中部分保存为…”选项以保存树元素。JMeter保存树元素时会连带的将它下面的子节点一起保存。通过这种方式，在后面的运用中你可以成段的或者单独的保存元素。

默认情况下，工作台不会被自动保存到测试计划，但是它能够通过在工作台元素上勾选“Save Workbean”去保存.

2.3 配置树元素

测试树中的任何元素在JMeter的右手框架中都被表现为控制器。这些控制器允许你为特定的测试元素配置行为。具体有哪些行为可以配置取决于是何种类型的元素。

测试树本身可以被测试树周围的拖放控件操作.

2.4 保存测试计划

尽管没有硬性要求，我们还是建议你在执行测试计划前先保存测试计划到文件。保存一个测试计划可以从文件按钮中选择“保存测试计划”或者“保存测试计划为…”（如果你是用的最新发布版本的JMeter，就不需要在保存之前先选中测试计划）

JMeter允许你保存整个测试计划树或者计划树里面的一部分。如果只是保存特定分支的计划树里面的元素，
可以从开始的分支里面选择测试计划树元素，右键选择“选中部分保存为…”菜单选项。或者也可以先选
择正确的测试计划元素然后通过编辑按钮选择“选中部分保存为…” 选项。

2.5 运行一个测试计划

运行测试计划，从“运行”菜单选项中选择“启动”（Control + R）按钮。当JMeter运行的时候，它会在菜单栏下面的左手边显示一个绿色的小盒子的形状。你也可以通过检查“运行”菜单选项去检查测试计划是否运行起来，如果“启动”是禁用的，并且 “停止” 是启用的，这样JMeter就正在运行你的测试计划。（或者至少在我看来是这样的）绿色边框左下角的数字就是活动线程除以总共线程，这种计算方式只是适用在本地运行测试测试；不包含任何在远程服务器上启动的线程当使用的是 客户端-服务器 模式的时候。

这里所描述的GUI模式只是适用于调试测试计划，如果运行真实的load test，请用非GUI模式。

2.6 停止测试

在菜单中有两种停止的测试命令可供选择：

停止（Control + .）-尽可能立即停止线程。很多采样器会被中断这意味着那些活跃的采样器也会被立即终止。停止命令会检查在默认设置的5s超时的时间内是不是所有的线程都终止了。[这个默认时间是可以通过JMeter（ jmeterengine.threadstop.wait）的属性设置的] 如果有线程没有终止，这时会有一条提示信息显示出来。停止命令会重试，如果还是失败，有必要通过直接退出JMeter去清理。
关闭（Control + ，）-请求在当前任何工作的末尾去结束线程，不会中途干扰活跃的采样器。这种情况下关闭对话框会一直保持活跃直到所有的线程都终止。如果关闭花费太长时间。关掉对话框选择 运行/停止 ，或者按下Control + . .

这儿是没有菜单的当运行non-GUI模式的时候，并且JMeter对像Control + . 这样的快捷键不会做出反应。因此JMeter non-GUI模式会在特定端口来监控这些命令。（默认端口是4445，参见JMeter的 jmeterengine.nongui.port 属性）。 Jmeter是支持自动切换端口的当默认端口被占用的时候（举个例子被其他Jmeter的实例占用）。在这种情况下，Jmeter会尝试更大数值的端口号，直到达到Jmeter 属性 jmeterengine.nongui.maxport 的最大值4455。如果最大端口小于或者等于端口号，端口扫描就不会发生。选择的端口会在控制窗口显示。

appium简明教程（2）——appium的基本概念

Sat, 19 Aug 2017 06:14:09 +0800

Client/Server Architecture

appium的核心其实是一个暴露了一系列REST API的server。

这个server的功能其实很简单：监听一个端口，然后接收由client发送来的command。翻译这些command，把这些command转成移动设备可以理解的形式发送给移动设备，然后移动设备执行完这些command后把执行结果返回给appium server，appium server再把执行结果返回给client。

在这里client其实就是发起command的设备，一般来说就是我们代码执行的机器，执行appium测试代码的机器。狭义点理解，可以把client理解成是代码，这些代码可以是java/ruby/python/js的，只要它实现了webdriver标准协议就可以。

这样的设计思想带来了一些好处：

1，可以带来多语言的支持；
2，可以把server放在任意机器上，哪怕是云服务器都可以；（是的，appium和webdriver天生适合云测试）

Session

session就是一个会话，在webdriver/appium，你的所有工作永远都是在session start后才可以进行的。一般来说，通过POST /session这个URL，然后传入Desired Capabilities就可以开启session了。

开启session后，会返回一个全局唯一的session id，以后几乎所有的请求都必须带上这个session id，因为这个seesion id代表了你所打开的浏览器或者是移动设备的模拟器。

进一步思考一下，由于session id是全局唯一，那么在同一台机器上启动多个session就变成了可能，这也就是selenium gird所依赖的具体理论根据。

Desired Capabilities

Desired Capabilities携带了一些配置信息。从本质上讲，这个东东是key-value形式的对象。你可以理解成是java里的map，python里的字典，ruby里的hash以及js里的json对象。实际上Desired Capabilities在传输时就是json对象。

Desired Capabilities最重要的作用是告诉server本次测试的上下文。这次是要进行浏览器测试还是移动端测试？如果是移动端测试的话是测试android还是ios，如果测试android的话那么我们要测试哪个app？ server的这些疑问Desired Capabilities都必须给予解答，否则server不买账，自然就无法完成移动app或者是浏览器的启动。

具体例子如下：

For example, we might set the platformName capability to iOS to tell Appium that we want an iOS session, rather than an Android one. Or we might set the safariAllowPopupscapability to true in order to ensure that, during a Safari automation session, we’re allowed to use JavaScript to open up new windows. See the capabilities doc for the complete list of capabilities available for Appium

（二）实战: 最简单的自动化脚本

Sat, 12 Aug 2017 08:26:17 +0800

目的

熟悉selenium webdriver 代码套路
体验元素定位的最简单情形
学会如何模拟输入键盘按键

如何学习

将代码抄一遍，然后精读一遍，了解每一行代码的意义。

场景

本节我们需要使用selenium打开chrome浏览器，跳转到百度首页(http://www.baidu.com)，在搜索框中输入selenium并按下回车键。

代码

新建文件simple_automation_script.js，并键入下面的内容。


var webdriver = require('selenium-webdriver'),
 By = webdriver.By,
 Key = webdriver.Key;

var dr = new webdriver.Builder().forBrowser('chrome').build();

dr.get('http://www.baidu.com')
dr.findElement(By.id('kw')).sendKeys('selenium');
dr.findElement(By.id('kw')).sendKeys(Key.RETURN);

console.log('quit driver');
dr.quit();

运行

在命令行中运行

node simple_automation_script.js

常见错误

WebDriverError: unknown error: unhandled inspector error: {"code":-32000,"message":"Cannot navigate to invalid URL"}

这是get时url拼写错误导致的，检查dr.get('http://www.baidu.com')这一行url地址是否准确。

NoSuchElementError: no such element: Unable to locate element: {"method":"css selector","selector":"*[id="www"]"}

selenium找不到元素时会报的错，这是selenium开发者最常见的错误，没有之一。上面错误提示中很明确的告诉我们，页面上没有id为www的元素。遇到这种问题时，我们需要多尝试几种定位元素的方式。

总结

new webdriver.Builder('browser name').build()语句可以打开我们指定的浏览器，另外使用Builder，我们还可以使用环境变量在运行时动态指定浏览器类型，这对于持续集成来说非常方便;
dr.findElement(By.id('element id'))语句使用id来定位具体的元素;
element.sendKeys('something')语句可以向文本框中输入具体的内容;
Key.RETURN代表回车键，这些具体的键值通常与sendKeys配合使用;

原始封面

性能测试基础（二）并发用户

Fri, 11 Aug 2017 14:59:11 +0800

![](http://img.testclass.net/vusers.png)
#### 并发的两种情况 ---- 一种是严格意义上的并发，即所有的用户在同一时间点做同一件事或操作，这种操作一般指做同一类型的业务。比如，所有用户同一时刻做并发登陆，同一时刻做表单提交。

另外一种并发是广义范围的并发，这种并发与前一种并发的区别是，尽管多个用户对系统发出了请求或者进行了操作，但是这些请求或都操作可以是相同的，也可以是不同的。比如，在同一时刻有用户在登录，有用户在提交表单。

从服务器的角度来看并发

前面的两种解释都是从用户业务的角度来解释并发的，因为我们平时所做的性能测试也是从用户端对业务层的操作来进行并发测试的。

如果考虑整个系统运行过程中服务器所承受的压力是这样的：在该系统的运行过程中，把整个运行过程划分为离散的时间点，在每个点上都有一个“同时向服务端发送请求的用户数”，这个就是所谓的服务器所承受的并发访问数。

#### 真正意义上的并发不存在 ----

从性能测试工具的角度来看，虽然，性能测试工具可以1秒模拟成千上万个请求，那么这些请求的产生同样分前后顺序。就算这些请求被真正的“同时”生产出来，通过网络传输到过服务器时，因为受网络带宽、延迟等影响，也无法真正的对服务器构成“同时”请求。

从服务器角度，当它接收到并发请求，在处理这些请求时同样需要分前后顺序，因为它处理每个请求的时间极短；每秒可以处理几千几万次请求；所以，我们说它的并发能力是每秒/次。

（注：这里假设模拟虚拟用户的服务器和系统服务器为单核CPU的情况下）

#### 系统用户数与同时在线人数 ----

在实际的性能测试中，经常还会遇到与并发相关的两个概念“系统用户数”与“同时在线人数”。

假设有一个网站，注册用户才能登录使用各种功能，如上传头像，阅读专家文章等。该系统有20万注册用户，这就是说有20万用户可以使用这个网站的所有功能，20万就是这个网站的“系统用户数”，网站有一个在线统计功能，从统计数据中可以看到，同时登录网站的人数的最高记录是2万，就是有2万人同时用浏览器打开着这个网站。2万就是“同时在线人数”。那么系统的并发用户数2万么？不是的！这2万只表示在系统最高峰时有这么多用户登录了网站，并不代表服务器的实际承受压力。因为服务器承受压力还与具体的用户访问模式相关，在这2万用户中考察某一个时间点对用户发出请求数，可以会大大缩水。那么，该系统的服务端承受的最大并发访问数是多少呢？这个取决于业务并发用户数和业务场景，一般可以通过服务器日志的分析得到。

原始封面

（二）软件测试分类

Thu, 27 Jul 2017 12:59:11 +0800

是一个典型的“V”模型软件开发流程，各项软件测试工作是在项目开发流程中循序渐进进行的。下面将介绍各个阶段测试的含义。

单元测试：单元测试（或模块测试）是对程序中的单个子程序或具有独立功能的代码段进行测试的过程。
集成测试：集成测试是在单元测试的基础上，先通过单元模块组装成系统或子系统，再进行测试。重点是检查模块之间的接口是否正确。
系统测试：系统测试是针对整个产品系统进行的测试，验证系统是否满足需求规格的定义，以及软件系统的正确性和性能等是否满足其需求规格的要求。
验收测试：验收测试是部署软件之前的最后一个测试阶段。验收测试的目的是确保软件准备就绪，向软件购买者展示该软件系统能够满足用户的需求。

#### 白盒测试、黑盒测试、灰盒测试

白盒测试与黑盒测试，主要是根据软件测试工作中对软件代码的可见程度进行的划分。这也是软件测试领域中最基本的概念之一。

黑盒测试

白盒测试

灰盒测试

灰盒测试介于黑盒测试与白盒测试之间。

#### 功能测试与性能测试

从软件的不同测试面可以划分为功能测试与性能测试。

功能测试

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

性能测试

性能测试是通过自动化的测试工具模拟多种正常、峰值以及异常负载条件来对系统的各项性能指标进行的测试。

软件的性能包括很多方面，主要有时间性能和空间性能两种。

空间性能：主要指软件运行时所消耗的系统资源，例如硬件资源，CPU、内存、网络带宽消耗等。

#### 手工测试与自动化测试

从对软件测试工作的自动化程度可以划分为手工测试与自动化测试。

手工测试

手工测试就是由测试人员一个一个地去执行测试用例，通过键盘鼠标等输入一些参数，并查看返回结果是否符合预期结果。

自动化测试

自动化测试又可分为：功能自动化测试与性能自动化测试。

性能自动化测试：通过性能工具来模拟成千上万的虚拟用户向系统发送请求，从而验证系统的处理能力。

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

这几种测试出现在软件测试的周期中，既不算具体明确的测试阶段，也不是具体的测试方法。

冒烟测试

是指在对一个新版本进行大规模的系统测试之前，先验证一下软件的基本功能是否实现，是否具备可测性。

回归测试

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

随机测试

是指测试中的所有输入数据都是随机生成的，其目的是模拟用户的真实操作，并发现一些边缘性的错误。

database测试笔试题1

Tue, 18 Jul 2017 09:30:25 +0800

主键的值可以为空么？

can the value of primary key be NULL? no

答案：不行

创建索引是为了提高性能么？

Is the index used to improve the peformance? 答案：yes

答案：是

关键字 select distinct 是用来分组的么？

is the keyword “select distinct” used to group result-set by one or more columns? no

答案：不是

哪个关键字是用来对结果排序？

which keyword is used to sort the result-set? order by

答案： Order by

哪个关键字是用来修改已经存在的数据？

which keyword is used to modify the existing records in table? update

（二）环境安装之IntelliJ IDEA

Thu, 06 Jul 2017 12:59:11 +0800

### 安装IntelliJ IDEA

你可能会问，为什么不用Eclipse呢？随着发展IntelliJ IDEA有超越Eclipse的势头，JetBrains公司的IDE基本上已经一统了各家主流编程语言的江湖。考虑到 Java IDE的流行趋势，本书中决定选用IntelliJ IDEA。

当然，选择什么样的IDE充满着个人喜好。你依然可以参考其它资料安装Java IDE。这不会影响你阅读该系列文章。点击 IntelliJ IDEA下载，根据自己的平台，选择相应的版本进行下载。

IntelliJ IDEA安装过程省略…

如果第一次打开IntelliJ IDEA，会看到如下界面。

点击"Create New Project"选项创建新的Java项目。选择项目类型为Java，然后，继续"Next"。

Project name: 项目名称。
Project location: 项目在硬盘上的路径。

点击"Finish"结束项目创建完成。

### 编写Hello World！

首先，打开IntelliJ IDEA，点击左侧项目列表，在src下面创建__包__和__类文件__。

1)右键左侧项目列表 src—>New —> Package 弹出窗口，输入包的名：javaBase。

2)右键左侧创建的包名：java —>New —> Java Class 弹出窗口，输入类的名：HelloWorld。

（二）selenium3 浏览器驱动

Thu, 29 Jun 2017 12:59:11 +0800

### 下载浏览器驱动

当selenium升级到3.0之后，对不同的浏览器驱动进行了规范。如果想使用selenium驱动不同的浏览器，必须单独下载并设置不同的浏览器驱动。

各浏览器下载地址：

Firefox浏览器驱动：geckodriver

Chrome浏览器驱动：chromedriver , taobao备用地址

IE浏览器驱动：IEDriverServer

Edge浏览器驱动：MicrosoftWebDriver

Opera浏览器驱动：operadriver

PhantomJS浏览器驱动：phantomjs

注：部分浏览器驱动地址需要科学上网。

### 设置浏览器驱动

设置浏览器的地址非常简单。我们可以手动创建一个存放浏览器驱动的目录，如： C:\driver , 将下载的浏览器驱动文件（例如：chromedriver、geckodriver）丢到该目录下。

我的电脑–>属性–>系统设置–>高级–>环境变量–>系统变量–>Path，将“C:\driver”目录添加到Path的值中。

Path
;C:\driver

### 设置浏览器驱动

验证不同的浏览器驱动是否正常使用。

from selenium import webdriver


driver = webdriver.Firefox() # Firefox浏览器

driver = webdriver.Chrome() # Chrome浏览器

driver = webdriver.Ie() # Internet Explorer浏览器

driver = webdriver.Edge() # Edge浏览器

driver = webdriver.Opera() # Opera浏览器

driver = webdriver.PhantomJS() # PhantomJS

……

趣谈软件需求分析

Tue, 17 Jun 2025 17:29:15 +0800

什么是需求分析？

通俗的讲，对用户的意图不断揭示和验叛的过程，要对经过系统可行性分析所确定的系统目标做更为详细的描述。

假如你是个建筑工程师，有个客户找你建一个鸡窝，这个时候要需要与客户沟通，来确定客户到底想要一个什么样子的鸡窝。我们应该注意三点：

1、准确的理解和描述客户需要的功能。

客户说，我的鸡窝要三层的，带电梯，饮水池，厕所，饮水池要自动判断水位供水，电梯要可以同时乘坐10只鸡….客户滔滔不绝的讲了一大堆，你也都非常忠实的按照自己的理解再一一的向客户描述一遍，以便于确认客户的需求是否正确。

2、帮助客户挖掘需求。

等客户把自己的需求说完了，你发现客户没有说鸡的卧室，于是，你向客户提议说：“你看，这鸡的卧室要什么样子的？”，客户连连的拍着脑门说，我差点给忘记了，鸡们啊喜欢晚上在一起聊天，所以呢，需要一个长而大的卧室，但一定要舒适。

3、分析客户需求的可行性。

客户临走时又说，最近啊，黄鼠狼很多，我这个鸡窝啊，一楼就不用盖了，直接盖二楼和三楼吧！以免晚上遭遇黄鼠狼的攻击。你这么一分析，客户这要求，按照目前的技术可没法建啊，于是，你向客户提议，一楼采用坚固架子来支撑二三楼的建筑。

#### 需求分析困难在哪儿？

有几种原因使需求分析变得困难：（1）客户说不清楚需求；（2）需求自身经常变动；（3）分析人员或客户理解有误。

1、客户说不清楚需求

有些客户对需求只有朦胧的感觉，当然说不清楚具体的需求。例如全国各地的很多政府机构在搞网络建设，这些单位的领导和办公人员大多不清楚计算机网络有什么用，反而要软件系统分析人员替他们设想需求。这类工程的需求是如此的主观，以致产生很多贪污腐败现象。

有些客户心里非常清楚想要什么，但却说不明白。你可能很不以为然。就举日常生活的事例吧，比如说买鞋子。我们非常了解自已的脚，但没法说清楚脚的大小和形状。只能拿鞋子去试，试穿时感觉到舒服才会买鞋（居然也有神通广大的售货员，看一眼客户的手，就知道应该穿什么样的鞋）。

如果客户本身就懂软件开发，能把需求说得清清楚楚，这样的需求分析将会非常轻松、愉快。如果客户全不懂软件，但信任软件开发方，这事也好办。分析人员可以引导客户，先阐述常规的需求，再由客户否定不需要的，最终确定客户真正的需求。最怕的就是“不懂装懂”或者“半懂充内行”的客户，他们会提出不切实际的需求。如果这些客户甚至觉得自己是上帝的爸爸，那么沟通和协商都会很困难。

2、需求自身经常变动

唐僧曾说：“妖要是有了仁慈之心，就不再是妖，是人妖。”（《大话西游之大圣娶亲》）

连妖都会变心，别说人了。所以喜新厌旧乃人之常情，世界也因此变得多姿多彩。

软件的需求会变化吗？

答：据历史记载，没有一个软件的需求改动少于三次。唯一只改动需求两次的客户是个死人。这个可怜的家伙还是在运送第三次需求的路上被车子撞死的。[Cline 1995]

让我们先接受“需求会变动”这个事实吧，免得在需求变动时惊慌失措。明白“需求会变动”这个道理后，在进行需求分析时就要留点神：

尽可能地分析清楚哪些是稳定的需求，哪些是易变的需求。以便在进行系统设计时，将软件的核心建筑在稳定的需求上，否则将会吃尽苦头。
在合同中一定要说清楚“做什么”和“不做什么”。如果合同含含糊糊，日后扯皮的事情就多。要防止象韩复渠那样，在别人请他喝酒吃饭时他什么都点头（人家就更加献殷勤），吃完了他就宣布刚才答应的事都不算数，便扬长而去。

3、分析人员和顾客理解有误

有个外星人间谍潜伏到地球刺探情报，它给上司写了一份报告：“主宰地球的是车。它们喝汽油，靠四个轮子滚动前进。嗓门极大，在夜里双眼能射出强光。……有趣的是，车里住着一种叫作‘人’的寄生虫，这些寄生虫完全控制了车。”

软件系统分析人员不可能都是全才。客户表达的需求，不同的分析人员可能有不同的理解。如果分析人员理解错了，可能会导致开发人员白干活，吃力不讨好。我读中学时候最怕写作文逃题，如果逃题了，不管作文写得多长，总是零分。所以分析人员写好需求说明书后，要请客户方的各个代表验证。如果问题很复杂，双方都不太明白，就有必要请开发人员快速构造软件的原型，双方再次论证需求说明书是否正确。

由于客户大多不懂软件，他们可能觉得软件是万能的，会提出一些无法实现的需求。有时客户还会把软件系统分析人员的建议或答复给想歪了。

有一个软件人员滔滔不绝地向客户讲解在“信息高速公路上做广告”的种种好处，客户听得津津有味。最后，心动的客户对软件人员说：“好得很，就让我们马上行动起来吧。请您决定广告牌的尺寸和放在哪条高速公路上，我立即派人去做。”

需求分析的分类

需求分析一般可分为功能需求、非功能需求和领域需求

1、功能需求

功能需求主要说明了系统实际应做到什么。这是用户最直观也是最主要的需求，如系统的输入输出、系统能完成的功能以及其它相关处理等；

2、非功能需求

非功能需求又称“约束”，它主要从各个角度对系统起约束和限制作用。如响应时间、存储效率、报表的规格和界面的样式等

3、领域需求

领域需求的来源不是用户，而是系统应用的领域，其主要反映了该领域的基本问题。例如勤工俭学管理系统，其领域需求就涉及到诸如应聘合同书、酬金发放及劳工考核等相关内容，如果这些需求得不到满足，系统就无法正常运行。值得一提的是，领域需求可能是功能需求，也可能是非功能需求。

如何进行需求分析

进行需求分析不象情人之间的浪漫做法——“让我摸摸你的头发，感觉它是什么颜色。”我们需要了解需求分析的渠道和过程。

需求分析的过程：

（1）可行性研究

它指明现有的软件、硬件技术能否实现用户对系统的要求，从业务角度来决定系统开发是否可行以及在预算范围内能否开发出来。可行性研究的结果是清楚的回答：该系统是否值得开发

（2）需求导出和分析

这是一个通过对现有系统分析、与潜在客户讨论、进行任务分析等导出系统需求的过程，也可能需要开发一个或多个不同的系统原型，以帮助分析员了解所要描述的系统。

（3）需求描述

需求描述就是把在分析活动中收集的信息通过分析整理之后以文档的形式确定下来。该文档中有两类需求：用户需求是从客户和最终用户角度对系统需求的抽象描述；系统需求是对系统要提供的功能的详尽描述。

（4）需求有效性验证

主要是通过评审、验证等一系列活动来找出需求文档中的错漏并加以改正。

（5）需求管理

需求管理需求管理是一种系统化方法，可用于获取、组织和记录系统需求并使用户和开发方在系统变更需求上始终保持一致

#### 需求分析的方法

1、功能分析方法

wrk系列教程(3)统计结果

Sun, 03 Mar 2019 02:00:11 +0800

回到上一节的统计结果，我们来看一下这些结果是如何统计出来的。

Running 30s test @ http://127.0.0.1:8000/index.html
 10 threads and 200 connections
 Thread Stats Avg Stdev Max +/- Stdev
 Latency 3.24ms 6.54ms 154.00ms 95.36%
 Req/Sec 167.54 227.05 1.81k 84.83%
 16145 requests in 30.08s, 3.13MB read
 Socket errors: connect 0, read 1208, write 31, timeout 0
Requests/sec: 536.78
Transfer/sec: 106.41KB

我们一行一行来看一下这些统计数据。

Running 30s test @ http://127.0.0.1:8000/index.html，测试持续时间已经被测url
10 threads and 200 connections，总共多少个thread和connection
Latency 3.24ms 6.54ms 154.00ms 95.36% ，时延的平均值，标准差以及最大值以及值落在标准差区间内的百分比
Req/Sec 167.54 227.05 1.81k 84.83%，每个线程运行时的qps平均值，标准差以及百分比区间。看了一圈源码，没太看懂这个统计的意义
16145 requests in 30.08s, 3.13MB read，总请求数，运行的总时间以及传输数据的总和
Socket errors: connect 0, read 1208, write 31, timeout 0，socket错误的统计
Requests/sec: 536.78，总请求数除以总的运行时间，也就是qps
Transfer/sec: 106.41KB，传输的总数据除以总的运行时间

原始封面

python简明教程: 3. 控制流

Tue, 20 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 3. 控制流
####################################################

# 定义变量
some_var = 5

# 这是if语句，注意缩进，在python里缩进非常重要！
# 结果是打印 "some_var is smaller than 10"
if some_var > 10:
 print "some_var is totally bigger than 10."
elif some_var < 10: # elif 分支是可选的
 print "some_var is smaller than 10."
else: # 这也是可选的
 print "some_var is indeed 10."

"""
用for去遍历list
打印结果:
 dog is a mammal
 cat is a mammal
 mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
 # 可以用{0}语法去格式化打印，参考之前的教程
 print "{0} is a mammal".format(animal)

"""
"range(number)" 返回1个列表，列表里包含一组数字
从0到number,不包含number
打印:
 0
 1
 2
 3
"""
for i in range(4):
 print i

"""
"range(lower, upper)" 返回1个列表，列表里包含一组数字
范围从lower到upper
prints:
 4
 5
 6
 7
"""
for i in range(4, 8):
 print i

"""
While会一直循环直到条件不再满足为止
prints:
 0
 1
 2
 3
"""
x = 0
while x < 4:
 print x
 x += 1 # x = x + 1 的简写

# try/except 代码库(block)用来处理异常

# 适用于Python 2.6及以上版本:
try:
 # 使用"raise"来抛出异常
 raise IndexError("This is an index error")
except IndexError as e:
 pass # Pass就是啥都不做.一般情况下，你会在这里做异常的恢复
except (TypeError, NameError):
 pass # 如果需要的话可以一次性处理多个异常
else: # else分支是可选的.必须出现在所有的except分支之后
 print "All good!" # 当且仅当try代码块中没有抛出任何异常时才会运行
finally: # 最后一定会执行
 print "We can clean up resources here"

# 除了使用try/finally之外，我们可以使用 with 语句来进行适当的简化
with open("myfile.txt") as f:
 for line in f:
 print line

原始封面

（三）Docker 镜像

Mon, 22 Jan 2018 14:45:11 +0800

Docker 运行容器前需要本地存在对应的镜像，如果镜像不存在本地， Docker 会从镜像仓库下载（默认是Docker Hub公共注册服务器中的仓库）。

Docker Hub:https://hub.docker.com 阿里云镜像：https://dev.aliyun.com/search.html 灵雀云：https://hub.alauda.cn/

镜像

查看镜像

列出本地镜像：

$ sudo docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest f2a91732366c 2 months ago

在列出信息中，可以看到几个字段信息：

来自于哪个仓库，比如 ubuntu
镜像的标记，比如 14.04
它的 ID 号（唯一）
创建时间
镜像大小

获取镜像

可以使用docker pull 命令来从仓库获取所需要的镜像。搜索 “ubuntu” 镜像。

$ sudo docker pull ubuntu

Using default tag: latest
latest: Pulling from library/ubuntu
8f7c85c2269a: Pull complete
9e72e494a6dd: Pull complete
3009ec50c887: Pull complete
9d5ffccbec91: Pull complete
e872a2642ce1: Pull complete
Digest: sha256:d3fdf5b1f8e8a155c17d5786280af1f5a04c10e95145a515279cf17abdf0191f
Status: Downloaded newer image for ubuntu:latest

该命令实际上相当于 $ docker pull registry.hub.docker.com/ubuntu 命令，即从注册服务器registry.hub.docker.com中的 ubuntu仓库来下载的镜像。

（三）Java的强类型定义

Wed, 17 Jan 2018 14:42:11 +0800

在由Python转向Java的一个最大的感受就是Java的类型定义。Java要求你所定义的常量/变量和方法必须要声明类型。

常量、变量

定义常量与变量。

public class JavaType {

 public static void main(String[] args) {
 final double PI = 3.14; //定义常量
 int R = 5; //定义变量
 System.out.printf("圆周率的面积:" + PI * R * R);
 }
}

final double：final用于定义常量，double为常量PI的类型。
int：为变量R的类型。

更多类型

更多一些常用的数据类型：

short s = 3; // 定义short类型变量
int i = 22; // 定义int类型变量
float f = 1.23f; // 定义float类型变量
char a = 'a'; // 定义字符类型用char
String string = "hello world"; // 定义字符串类型String
boolean status = true; // 定义布尔类型类型用 boolean

数组与HashMap

这种强类型还体现在数组和HashMap中。

TDD实战（三）“井字游戏” 需求二

Mon, 08 Jan 2018 12:50:11 +0800

需求2

现在处理轮到哪个玩家落子问题。

需要提供一种途径，用于判断接下来该谁落子。

将需求分成三个测试：

玩家 X 先下；
如果上一次是 X 下的，接下来将轮到 O 下。
如果上一次是 O 下的，接下来将轮到 X 下。

测试用例1

import static org.junit.Assert.*;

……

@Test
public void givenFirstTurnWhenNextPlayerThenX(){
 assertEquals('X', ticTacToe.nextPlayer());
}

在这条用例中用到了 JUnit 的断言方法 assertEquals()，通过 nextPlayer() 判断下一个下棋的是否是 X 玩家。

实现代码1

对于当前的测试用例来说，根本不需要检查玩家 X 是否先下，因为就目前而言，只需要让 nextPlayer() 返回 X 就能让测试释通过。

在 TicTacToe 类中添加 nextPlayer() 方法。

public char nextPlayer() {
 return 'X';
}

** 执行测试用例1 检查它是否运行通过。

测试用例2

现在需要确保让玩家轮流下，玩家 X 下棋后，应轮到玩家 O，然后再轮到玩家 X，以此类推：

Android测试（三）：Android 单元测试

Wed, 20 Dec 2017 14:45:12 +0800

原文：https://developer.android.com/training/testing/unit-testing/index.html

单元测试是你的应用程序测试策略的基本测试。通过针对您的代码创建和运行单元测试，你可以轻松验证各个单元的逻辑是否正确。在每次构建之后运行单元测试可帮助你快速捕获并修复由代码更改引入到应用程序的软件回归。

单元测试通常以可重复的方式实现尽可能小的代码单元（可以是方法，类或组件）的功能。当你需要验证应用程序中特定代码的逻辑时，你应该构建单元测试。例如，你创建了一个类，单元测试可以帮助检查该类是否处于正确的状态。通常，单元测试是相对独立的，你的测试只会影响和检查被测试单元的变更，mock框架可以用来隔离你要测试单元的依赖。

注意：单元测试不适合测试复杂的UI交互事件。相反，您应该使用UI测试框架，如UI自动化测试中所述。

为了测试Android应用程序，你通常需要创建这些类型的单元测试：

本地测试： 仅在本地机器上运行的单元测试。这些测试被编译为在Java虚拟机（JVM）本地运行，以最小化执行时间。使用这种方法来运行没有依赖于Android框架的单元测试，或者可以使用mock对象来填充依赖关系。
Instrumented测试： 在Android设备或模拟器上运行的单元测试。这些测试可以访问工具信息，例如被测试的应用程序的上下文。使用此方法运行具有Android依赖关系的单元测试，这些测试不能使用mock对象轻松填充。

接下来将告诉你如何构建这两种类型单元测试。

本课的教训将告诉您如何构建这些类型的自动化单元测试。

Lessons

Building Local Unit Tests（创建本地单元测试）

学习如何构建在本地机器上运行的单元测试。

Building Instrumented Unit Tests（创建Instrumented单元测试）

了解如何构建在Android设备或模拟器上运行的单元测试。

原始封面

Fiddler（三）代理 HTTP 请求

Tue, 19 Dec 2017 13:55:11 +0800

上一小节对Fiddler的界面了简单的认识。接下来介绍如何通过Fiddler拦截HTTP请求。

代理 HTTP 请求

启动 Fiddler:

1、 启动代理 ：点击窗口左下角，显示 “Capuring” 侧说明当前处于代理状态。

2、通过浏览器访问相关网页或执行页面操作（如，登录、搜索）。

3、通过Fiddler查看代理的HTTP请求进行分析。

清除请求

当Fiddler拦截的请求比较多时，不方便查看，我们可以清除已经代理的请求，重新代理。如上图，Fiddler提供了几种清理选项。

Remove all ：清空整个请求列表
Images ：清除图片请求
COMMECTs ：清除HTTP的CONNECT请求
Non-200s ：清除HTTP状态不是 200 的请求
……

原始封面

最简单的web爬虫:获取所有课程信息

Sat, 16 Dec 2017 02:52:34 +0800

获取所有课程信息

我们现在来实现第一个超级简单的网络爬虫用来抓取重定向科技目前开设的所有测试课程，并打印出来，步骤大概是这样子

先访问所有课程页面，把html代码拿到，实际上就是拿到一个很长的文本，文本内容就是网页的html代码
分析html代码，找到我们需要获取信息的html特征
解析html代码，根据html特征，从里面抠出来课程的名称
打印出所有课程的名称

分析html代码

我们在编写爬虫的时候往往会花很多时间在分析html代码上，毕竟重要的信息都包含在html代码中，我们需要找到合适的特征，通过固定的套路去解析html，获取特定内容。

课程名称部分的html代码如下所示

<div class="col-md-3 col-sm-6">
 <div class="servive-block-in servive-block-colored servive-block-grey">
 <h4>性能测试从入门到精通班</h4><div><i class="icon-rocket"></i>
 </div>
 <p>2017年09月23日开课，为期3个月</p>
</div>

可以看到，课程名称的html标签是h4，通过搜索整个页面，我们发现页面上只有4个h4，也就是说，只要获取到页面上所有的h4，我们就能把课程名称给解析出来。

分析html一般有下面一些套路

缩小范围: 只解析特定区域的html，比如只遍历<nav></nav>标签中的子元素
组合属性: 有一些节点的属性是相同的，但我们经常只需要获取其中一些节点的内容，这时候可以通过组合该节点属性和其父节点属性的方式指定特定的节点
先遍历后过滤：还是上面一种情况，我们也可以先遍历所有的目标节点，再从目标节点中过滤出我们感兴趣的内容

解析html代码

大家可以先去了解一下html的基础知识，比较有用的是

Beautiful Soup库可以帮我们解析html代码，所谓的解析，无非是做下面的一些事情

从html文档中找到一些元素
获取某个元素或者一些元素的属性
获取某个元素或者一些元素的文本

在这个例子里，我们就是要找到所有h4元素，并获取所有h4元素的文本。

代码

新建名为get_courses.py的文件，输入下面的内容

import requests
from bs4 import BeautifulSoup

url = 'http://www.itest.info/courses' # 定义被抓取页面的url
# 获取被抓取页面的html代码，并使用html.parser来实例化BeautifulSoup，属于固定套路
soup = BeautifulSoup(requests.get(url).text, 'html.parser')
# 遍历页面上所有的h4
for course in soup.find_all('h4'):
 # 打印出h4的text属性
 print(course.text)

运行

在命令行中输入

python get_courses.py

预期结果

如果一切正常，那么应该可以看到下面的结果

性能测试从入门到精通班
接口自动化测试开发--Python班
Selenium自动化测试--Java班
Selenium自动化测试--Python班

原始封面

（三）如何做一些测试桩 (Stub)

Sat, 25 Nov 2017 12:50:11 +0800

何做一些测试桩 (Stub)

例子：

import org.junit.Test;

import java.util.LinkedList;

import static org.mockito.Mockito.*;



public class MockitoDemo {



 @Test(expected = RuntimeException.class)
 public void when_thenReturn(){
 //You can mock concrete classes, not only interfaces
 // 你可以mock具体的类型,不仅只是接口
 LinkedList mockedList = mock(LinkedList.class);

 //stubbing
 // 测试桩
 when(mockedList.get(0)).thenReturn("first");
 when(mockedList.get(1)).thenThrow(new RuntimeException());

 //following prints "first"
 // 输出“first”
 System.out.println(mockedList.get(0));

 //following throws runtime exception
 // 抛出异常
 System.out.println(mockedList.get(1));

 //following prints "null" because get(999) was not stubbed
 // 因为get(999) 没有打桩，因此输出null
 System.out.println(mockedList.get(999));

 //Although it is possible to verify a stubbed invocation, usually it's just redundant
 //If your code cares what get(0) returns then something else breaks (often before even verify() gets executed).
 //If your code doesn't care what get(0) returns then it should not be stubbed. Not convinced? See here.
 // 验证get(0)被调用的次数
 verify(mockedList).get(0);
 }

}

默认情况下，所有的函数都有返回值。mock函数默认返回的是null，一个空的集合或者一个被对象类型包装的内置类型，例如0、false对应的对象类型为Integer、Boolean；

（三）Maven 设置仓库地址

Sat, 25 Nov 2017 12:45:11 +0800

修改本地仓库地址

maven 用来管理我们的 Java 第三方库，我们需要设置仓库的本地地址来存放这此第三方库。

打开 Maven 目录下的配置文件（\apache-maven-3.5.0\conf\settings.xml) ，找到 <localRepository> ..</localRepository> 标签。

<!-- localRepository
 | The path to the local repository maven will use to store artifacts.
 |
 | Default: ${user.home}/.m2/repository
-->
<localRepository>D:/Java/maven/repo</localRepository>

Maven 默认将本地仓库设置在 ${user.home}/.m2/repository 目录下，这里修改为 D:/Java/maven/repo 路径。

设置中央仓库地址

中央仓库即当我们要用到 Java 的第三方库时应该去哪里下载。

同样打开 Maven 目录下的配置文件（\apache-maven-3.5.0\conf\settings.xml) ，找到 <mirrors>..</mirrors> 标签。

<mirrors>
 <!-- mirror
 | Specifies a repository mirror site to use instead of a given repository. The repository that
 | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
 | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
 |
 <mirror>
 <id>mirrorId</id>
 <mirrorOf>repositoryId</mirrorOf>
 <name>Human Readable Name for this Mirror.</name>
 <url>http://my.repository.com/repo/path</url>
 </mirror>
 -->
 <mirror>
 <id>alimaven</id>
 <name>aliyun maven</name>
 <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
 <!--<mirrorOf>central</mirrorOf> -->
 <mirrorOf>*</mirrorOf>
 </mirror>
</mirrors>

这里将 Maven 的中央仓库地址修改为 aliyun ，国内访问速度会更快。

（三）TestNG 之 FixTrue

Sat, 25 Nov 2017 12:45:11 +0800

什么是Fixture

Test Fixture 是指一个测试运行所需的固定环境，准确的定义：

The test fixture is everything we need to have in place to exercise the SUT

在进行测试时，我们通常需要把环境设置成已知状态（如创建对象、获取资源等）来创建测试，每次测试开始时都处于一个固定的初始状态；测试结果后需要将测试状态还原，所以，测试执行所需要的固定环境称为 Test Fixture。

TestNG 提供的 Fixture 方法

表：

注解	说明
@BeforeSuite	注解的方法在测试套件（中的所有用例）开始前运行一次
@AfterSuite	注解的方法在测试套件（中的所有用例）结束后运行一次。
@BeforeClass	注解的方法在当前测试类（中所有用例）开始前运行一次。
@AfterClass	注解的方法在当前测试类（中所有用例）结束后运行一次。
@BeforeTest	对于套件测试，在运行属于标签内的类的所有测试方法之前运行。
@AfterTest	对于套件测试，在运行属于标签内的类的所有测试方法之后运行。
@BeforeGroups	在调用属于该组的所有测试方法之前运行。
@AfterGroups	在调用属于该组的所有测试方法之后运行。
@BeforeMethod	注解的方法将在每个测试方法之前运行。
@AfterMethod	注释的方法将在每个测试方法之后执行。

实例

接下来通过例子演示上面部分注解的用法。

import org.testng.annotations.*;


public class FixtureTest {

 //在当前测试类开始时运行。
 @BeforeClass
 public static void beforeClass(){
 System.out.println("-------------------beforeClass");
 }

 //在当前测试类结束时运行。
 @AfterClass
 public static void afterClass(){
 System.out.println("-------------------afterClass");
 }

 //每个测试方法运行之前运行
 @BeforeMethod
 public void before(){
 System.out.println("=====beforeMethod");
 }

 //每个测试方法运行之后运行
 @AfterMethod
 public void after(){
 System.out.println("=====afterMethod");
 }

 @Test
 public void testCase1(){
 System.out.println("test case 1");
 }

 @Test
 public void testCase2(){
 System.out.println("test case 2");
 }


}

运行上面的测试，执行结果如下。

requests如何发送post请求?

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

发送post请求跟发送get请求类似，使用requests.post方法就可以了，如果需要传post data的话，直接将data以dict的格式传递就好。

>>> import requests
>>> r = requests.post('http://httpbin.org/post', data = {'key':'value'})

（三）JUnit 编写单元测试

Mon, 13 Nov 2017 12:50:11 +0800

编写单元测试

创建 JunitDemo 类，编写第一个单元测试用例。

import static org.junit.Assert.assertEquals;
import org.junit.Test;


public class JunitDemo {

 @Test
 public void myFirstTest() {
 assertEquals(2+2, 4);
 }

}

@Test 用来注释一个普通的方法为一条测试用例。

assertEquals() 方法用于断言两个值是否相关。

测试功能模块

创建一个被测试类：Count ，代码如下：

public class Count {

 /**
 * 计算并返回两个参数的和
 */
 public int add(int x ,int y){
 return x + y;
 }
}

Count 类的实现非常简单，看注释就可以了。

接下来，创建 CountTest 类，用于测试 Count 类。

import static org.junit.Assert.assertEquals;
import org.junit.Test;


public class CountTest {

 @Test
 public void testAdd() {
 Count count = new Count();
 int result = count.add(2,2);
 assertEquals(result, 4);
 }

}

new 出 Count 类，调用 add() 方法并传参，通过 assertEquals() 断言返回结果。

3. 实例: 测试弱密码

Wed, 08 Nov 2017 06:23:31 +0800

背景

考虑这样一个测试弱密码的实例，这个我们在pytest相关教程中也有过描述。

我们需要判断用户的密码中包含简单密码，规则是这样的，密码必须至少6位，满足6位的话判断用户的密码不是password123或者password之类的弱密码。

对于如下的测试数据，我们要如何使用unittest来进行相关测试呢？

[
 {"name":"jack","password":"Iloverose"},
 {"name":"rose","password":"Ilovejack"},
 {"name":"tom","password":"password123"}
]

Test fixture

前文我们也说过，text fixture的主要功能是初始化测试数据或环境以及清理测试数据或环境。

考虑上面的例子，对我们而已，在用例执行之前初始化上面的测试数据是有必要的，我们可以把上面的数据用python的数据结构来表示，比较合适的数据结构是python的字典。这样做有如下的好处

统一初始化一些需要在多个用例之间共享的数据
可以在初始化的时候做一些数据的处理工作，比如过滤一些无效数据等

Test fixture最简单的实现方式是通过自定义下面的2个方法:

TestCase.setUp方法在每个测试方法运行之前都会运行一次，适合为每个用例都初始化一遍数据
TestCase.tearDown方法在每个测试方法运行之后都会运行一次，适合为每个用例都清理一遍数据

代码

新建名为test_password_1.py的文本文件，输入如下内容

import unittest

class PasswordTeseCase(unittest.TestCase):

 def setUp(self):
 print('set up')
 self.test_data = [
 dict(name='jack', password='Iloverose'),
 dict(name='rose', password='Ilovejack'),
 dict(name='tom', password='password123')
 ]

 def test_week_password(self):
 for data in self.test_data:
 passwd = data['password']

 self.assertTrue(len(passwd) >= 6)

 msg = "user %s has a weak password" %(data['name'])
 self.assertTrue(passwd != 'password', msg)
 self.assertTrue(passwd != 'password123', msg)

 def test_dummy(self):
 pass

if __name__ == '__main__':
 unittest.main()

运行

在命令行里输入 python test_password_1.py来运行用例，结果如下

$ python test_password_1.py
set up
.set up
F
======================================================================
FAIL: test_week_password (__main__.PasswordTeseCase)
----------------------------------------------------------------------
Traceback (most recent call last):
 File "test_password_1.py", line 21, in test_week_password
 self.assertTrue(passwd != 'password123', msg)
AssertionError: False is not true : user tom has a weak password

----------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

解释一下

setUp方法运行了2次，所以打印出了2次’set up’，这是因为上面的用例中有2个测试方法(2个方法名以test开头的方法)，setUp会在每个测试方法执行之前执行1次

3. 数字和计算

Sun, 05 Nov 2017 08:17:22 +0800

背景

几乎所有的编程语言都支持数学计算。不要认为不是数学高手就不能学习编程，很多时候我们在代码里只会用到非常简单的数学运算，常见的有

+: 加法
-: 减法
/: 除法
*: 乘法
%: 整除取余
<: 小于
: 大于
=: 大于等于
<=: 小于等于

考虑这样的场景，我们的测试用例一个分布在3个模块(A/B/C)，A模块有30个用例，成功运行27个, B模块有40个用例，全部成功运行，C模块有30个用例全部运行成功，假设每个用例执行一次平均需要5分钟，打印出一些测试报告的明细。

代码实现

新建名为report_with_math.py，内容如下

# 打印出本次测试的测试结果
# A: 27/30 B: 40/40 C: 30/30

print('本次测试覆盖了3个模块')
print('测试用例总数为: ', 30 + 40 + 30)
print('执行的测试用例总数为: ', 30 + 40 + 30)
print('用例最多的模块是B模块，B模块比A模块多出的用例数为', 40 - 30)
print('A模块执行成功27个用例，执行失败的用例数为', 30 - 27)
print('B模块的用例全部执行通过， 通过率为百分之', (40 / 40) * 100)
print('C模块的用例全部执行通过， 通过率为百分之', (30 / 30) * 100)
print('B模块的用例比C模块多吗?', 40 > 30)
print('A模块的用例比C模块多吗?', 30 > 30)
print('B模块的用例比C模块少吗?', 40 < 30)

# 结束打印
print('回归不通过')

运行

在命令行中使用下面的命令去执行代码

python report_with_math.py

你应该可以看到

如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

本次测试覆盖了3个模块
测试用例总数为: 100
执行的测试用例总数为: 100
用例最多的模块是B模块，B模块比A模块多出的用例数为 10
A模块执行成功27个用例，执行失败的用例数为 3
B模块的用例全部执行通过， 通过率为百分之 100.0
C模块的用例全部执行通过， 通过率为百分之 100.0
B模块的用例比C模块多吗? True
A模块的用例比C模块多吗? False
B模块的用例比C模块少吗? False
回归不通过

动手时间

在每一行上面用#加上注释，解释一下这行代码的作用
找一些自己需要计算的东西，比如早餐吃3个包子才能吃饱，每个包子3块钱，那么早餐要花多少钱才能吃饱。建立.py文件去计算并执行
算一下模块A的通过率，找资料了解一下python的浮点数(float)类型，模块A的通过率的预期结果应该是0.9

常见问题

%号是怎么工作的: 取余数，比如 15 % 4 的结果是3, 16 % 4的结果是0；
运算符号的优先级是怎么样的: 跟我们小时候学习的四则混合运算一样，乘除优先于加减，有括号的话括号优先，把握不准的情况下，把需要优先计算的部分用括号括起来;

原始封面

3.Assert

Wed, 01 Nov 2017 07:22:42 +0800

Assert就是断言，每个测试用例都需要断言。

与unittest不同，pytest使用的是python自带的assert关键字来进行断言，大大降低了学习成本。

assert关键字后面可以接一个表达式，只要表达式的最终结果为True，那么断言通过，用例执行成功，否则用例执行失败。

详尽的用例失败描述

pytest的用例失败描述非常详尽，一目了人。考虑下面的例子

# content of test_assert1.py
def f():
 return 3

def test_function():
 assert f() == 4

执行上面的用例

$ pytest test_assert1.py
======= test session starts ========
platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
rootdir: $REGENDOC_TMPDIR, inifile:
collected 1 item

test_assert1.py F

======= FAILURES ========
_______ test_function ________

 def test_function():
> assert f() == 4
E assert 3 == 4
E + where 3 = f()

test_assert1.py:5: AssertionError
======= 1 failed in 0.12 seconds ========

可以很明显的看出，pytest给出的错误提示是：f()的值是3，也就是实际结果是3，而预期结果是4，3不等于4，因此断言未通过，用例失败。

3. Find

Fri, 27 Oct 2017 06:55:26 +0800

webium.find.Find 方法可以在页面或者其他容器中定位元素，返回WebElement实例。

Find方法的主要用到2个参数分别是

by: 定位策略，比如By.ID
value: 定位元素时用到的具体属性值

from selenium.webdriver.common.by import By
from webium import BasePage, Find

class SomePage(BasePage):
 buy_btn = Find(by=By.CSS_SELECTOR, value='a.buy-btn')

 def __init__(self):
 super(SomePage, self).__init__(url='http://itest.info')


if __name__ == '__main__':
 page = SomePage()
 page.open()
 page.buy_btn.click()

ui_type

在定位一些自定义的对象时我们可以指定ui_type参数来定制化Find的行为。

from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
from webium import BasePage, Find

class Link(WebElement):
 def is_secure(self):
 return self.get_attribute('href').startswith('https://')


class TypedPage(BasePage):
 join_link = Find(Link, By.CSS_SELECTOR, 'a.hover-effect')

 def __init__(self):
 super(TypedPage, self).__init__(url='http://itest.info')


if __name__ == '__main__':
 page = TypedPage()
 page.open()
 print('Is link secure: ' + str(page.join_link.is_secure()))

上面的例子里，我们定义了Link类，继承自WebElement，用以代表一般性的链接。is_secure()方法用来判断链接是否是https协议的。

join_link = Find(Link, By.CSS_SELECTOR, 'a.hover-effect')表示定位元素，并返回类型是Link的实例。

context 上下文

有时候你可能在用例运行时才可以确定页面的结构，现代网页是动态且多变的。如果你不能在类属性的定义中使用Find，那么你应该直接把该页面对象直接传到定位代码里。

from selenium.webdriver.common.by import By
from webium import BasePage, Find

class DynamicPage(BasePage):
 def __init__(self):
 super(DynamicPage, self).__init__(url='http://itest.info')

 def get_link_by_href(self, href):
 return Find(by=By.CSS_SELECTOR, value='a[href*="{0}"]'.format(href), context=self)


if __name__ == '__main__':
 page = DynamicPage()
 page.open()
 page.get_link_by_href('registration').click()

上面的例子里, get_link_by_href(self, href)方法通过动态传入的href来定为不同的对象，这时候就需要把self传入Find的对应上下文里，这是套路，因为Find方法就是这么设计以便正常工作的。

收藏清单: python持续集成测试报告及其他最全资源汇总

Wed, 25 Oct 2017 08:19:06 +0800

Continuous Integration 持续集成

buildbot - 自动化编译发布系统。大部分的软件项目可用
jenkins - 可扩展的开源持续集成server
travis-ci - 免费的持续集成平台

Reporting 报告

allure pytest - PyTest的allure适配器
HTMLTestRunner - Python 标准库unittest的扩展. 生成简单好用的html报告
unittest-xml-reporting - 一个unittest test runner可以将测试结果保存到 XML文件。可高度定制

Documentation generation 文档生成

Sphinx - Python文档生成器
MkDocs - Markdown语法友好的文档生成器
Pycco - The original quick-and-dirty, hundred-line-long, literate-programming-style documentation generator.

Editors, IDE, consoles 编辑器, IDE以及命令行工具

pycharm - 智能的专业的python IDE
pydev - eclipse 上全功能的python插件
sublime - 简洁好用的文本编辑器
ipython - 支持多语言的交互式shell, 最初是为python开发

Useful libs 有用的库

一些可以让你构建更好的自动化测试的库

（三）Jenkins 创建构建任务

Mon, 16 Oct 2017 13:00:11 +0800

构建项目类型

点击 Jenkins 首页 “创建一个新任务” 的链接，弹出如图3.1所示页面。

图3.1 选择Jenkins任务类型

Jenkins 提供了六种类型的任务。

构建一个自由风格的软件项目

这是Jenkins的主要功能。Jenkins 会结合任何 SCM 和任何构建系统来构建你的项目, 甚至可以构建软件以外的系统。

Pipeline

Orchestrates long-running activities that can span multiple build slaves. Suitable for building pipelines (formerly known as workflows) and/or organizing complex activities that do not easily fit in free-style job type. – 很难用一两句话说清 Pipeline, 参考 , 后面另起一文来介绍。

构建一个多配置项目

适用于多配置项目,例如多环境测试、平台指定构建,等等。

GitHub Organization

Scans a GitHub organization (or user account) for all repositories matching some defined markers. –这个主要针对由 Github 托管的项目。

（三）Locust 创建性能测试

Mon, 16 Oct 2017 12:00:11 +0800

Locust 可没有傻瓜式的脚本录制功能，要想用它来做性能测试，必须撸起袖子来写代码。不过。它并不难！

编写简单的性能测试脚本

创建 load_test.py 文件，通过 Python 编写性能测试脚本。

from locust import HttpLocust, TaskSet, task

# 定义用户行为
class UserBehavior(TaskSet):

 @task
 def baidu_index(self):
 self.client.get("/")


class WebsiteUser(HttpLocust):
 task_set = UserBehavior
 min_wait = 3000
 max_wait = 6000

UserBehavior类继承TaskSet类，用于描述用户行为。

baidu_index() 方法表示一个用户为行，访问百度首页。使用@task装饰该方法为一个事务。client.get()用于指请求的路径“/”，因为是百度首页，所以指定为根路径。

WebsiteUser类用于设置性能测试。

task_set ：指向一个定义的用户行为类。
min_wait ：执行事务之间用户等待时间的下界（单位：毫秒）。
max_wait ：执行事务之间用户等待时间的上界（单位：毫秒）。

执行性能测试

启动性能测试

> locust -f .\load_test.py --host=https://www.baidu.com

[2017-10-16 16:44:40,839] DESKTOP-SMGQBBM/INFO/locust.main: Starting web monitor at *:8089
[2017-10-16 16:44:40,842] DESKTOP-SMGQBBM/INFO/locust.main: Starting Locust 0.8

-f 指定性能测试脚本文件。
–host 指定被测试应用的URL的地址，注意访问百度使用的HTTPS协议。

通过浏览器访问：http://localhost:8089（Locust启动网络监控器，默认为端口号为: 8089）

设置测试

02. 教程介绍（新用户必看）

Mon, 16 Oct 2017 11:00:11 +0800

关于

学习前提

由于 IntelliJ IDEA 官网在亚洲没有设服务器，且官网用到一些类似 Twitter、Facebook 等站的脚本会使得你在国内出现访问巨慢或是不允许访问的特殊情况，所以建议你在访问官网、访问插件库、小版本本地迭代更新等操作的时候出现奇怪问题的时候，请自备VPN等网络加速工具。

很多用户都是先学习了 Eclipse、MyEclipse 再转到 IntelliJ IDEA 的，这里需要先说明的是，在学习 IntelliJ IDEA 过程中，你暂且要放下 Eclipse 下的开发思维方式，不能按 Eclipse 的软件思想或是结构去要求 IntelliJ IDEA，这样对你学习 IntelliJ IDEA 非常不利。

适用人群

用 IntelliJ IDEA 进行开发语言的学习者。

用 IntelliJ IDEA 进行开发语言的开发工作者。

其中对于语言开发学习者我是非常建议你使用 IntelliJ IDEA，因为一些代码格式、命名规范在 IntelliJ IDEA 下都是有良好的提示，对于我们所处的输入法下的中文全角符号也可以得到快速发现。特别是学习 Python 的学习者，当你在用 Pycharm 进行学习的时候，Pycharm 会时刻告诉你什么时候要注意空格、换行，提醒你有 PEP8 编码规范，你也可以通过快捷键快速格式化出适合 Python 要求的代码，这对于学习者来讲，真的很重要，它可以让你更专注于自己的代码。

教程演示的 IntelliJ IDEA 版本

IntelliJ IDEA 13 版本和 14 版本，在设置上差异很大，14 版本 IntelliJ IDEA 对整个 IDE 的设置进行了重新编排、归类，但是细节设置上所沿用的介绍是没有多大改变的。

目前（2015 年 06 月）IntelliJ IDEA 官网最新版本信息为：Version:14.1.4 Build:141.1532.4 Released:June 19th, 2015。

（三）Web Services技术之REST

Thu, 21 Sep 2017 00:00:11 +0800

REST 定义了一组体系架构原则，你可以根据这些原则设计以系统资源为中心的 Web Services ，包括使用不同语言编写的客户端如何通过HTTP处理和传输资源状态。如果考虑使用它的 Web Services 的数量，REST 近年来已经成为最主要的 Web Services 设计模型。事实上，REST 对 Web 的影响非常大，由于它的使用非常方便，已经普遍地取代了基于 SOAP 和 WSDL 的接口设计。

REST

Representational State Transfer，简称 REST ，中文翻译为 “表现层状态转化” 。

REST 具有夸语言、夸平台的特点。所以，它是一种遵循 REST 风格的 Web Services。

如果一个架构符合 REST 原则，就称它为 REST ful架构。要理解 REST ful架构，最好的方法就是去理解 Representational State Transfer 这个词组到底是什么意思，它的每一个词代表了什么涵义。如果你把这个名称搞懂了，也就不难体会 REST 是一种什么样的设计。

一、资源（Resources）

REST 的名称 “表现层状态转化” 中，省略了主语。 “表现层” 其实指的是 “资源” （Resources）的 “表现层” 。

所谓 “资源” ，就是网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的实在。你可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的URI。要获取这个资源，访问它的URI就可以，因此URI就成了每一个资源的地址或独一无二的识别符。

所谓 “上网” ，就是与互联网上一系列的 “资源” 互动，调用它的 URI。

二、表现层（Representation）

“资源” 是一种信息实体，它可以有多种外在表现形式。我们把 “资源” 具体呈现出来的形式，叫做它的 “表现层” （Representation）。

（四）soapUI介绍与安装

Wed, 20 Sep 2017 23:00:11 +0800

soapUI 是一款针对 REST 、SOAP 和其它的 API 自动化测试框架。

如果不理解什么是 SOAP 和 REST , 参考：

（二）Web Services技术之SOAP

（三）Web Services技术之REST

什么是soapUI?

(SoapUI is the world’s most widely-used open source API testing tool for SOAP and REST APIs. SoapUI offers SOAP Web Services functional testing, REST API functional testing, WSDL coverage, message assertion testing and test refactoring. With over 10 years of experience backed by a vast open source community, SoapUI is the de facto method for ensuring quality when developing APIs and Web Services.)

appium新手入门（3）—— 安装 appium Server

Thu, 07 Sep 2017 11:24:12 +0800

我们可以在Appium官方网站上下载操作系统相应的Appium版本。

https://bitbucket.org/appium/appium.app/downloads/

当前最新版本为 AppiumForWindows_1_4_16_1.zip ，注意这是一个 Windows 版本，如果你的电脑为MAC请下载 appium-1.5.3.dmg 。虽然你已经看到了这些下载包，但我不保证你能下载的下来。

所以，再来提供一个百度网盘的下载链接：https://pan.baidu.com/s/1pKMwdfX

我们以 Windows 为例，将下载的 AppiumForWindows.zip 进行解压，点击 appium-installer.exe 进行安装。

根据提示，一步一步进行安装，这里不再啰嗦。最终在会桌面上生成 Appium图标 , 双击启动，appium server 界面如下。

Appium-Server已经可以打开了。至于Appium的使用我们放到后面的章节进行介绍。

最后，打开Windows命令提示符，输入“appium-doctor”命令，如果出现以下提示，说明你Appium所需要的各项环境都已准备完成。

注：如果提示：“appium-doctor”不是内部或外部命令，找到Appium的安装目录，例如：

C:\Program Files\Appium\node_modules\.bin

添加到环境变量path下面（参考Java环境的设置）。

原始封面

（三）Git提交代码到GitHub

Thu, 31 Aug 2017 02:00:11 +0800

请先阅读：GitHub注册与Git安装

GitHub创建项目

在GitHub选择并创建一个项目。首先，登录 GitHub，单击页面右上角加号__“+”__ ，选择__“New repository”__ 选项。

填写项目名称及描述，默认项目为“Public”,如果想创建“Private”项目，GitHub需要收费。最后单击“Create repository”完成项目的创建，如下图所示。

项目名称为：project-name

创建完一个项目之后，GitHub会提示我们如何提交项目到它上面。

Quick setup — if you’ve done this kind of thing before
HTTPS https://github.com/defnngj/project-name.git
SSH git@github.com:defnngj/project-name.git

…or create a new repository on the command line

echo # project-name >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin git@github.com:defnngj/project-name.git
git push -u origin master

…or push an existing repository from the command line

git remote add origin git@github.com:defnngj/project-name.git
git push -u origin master

…or import code from another repository

You can initialize this repository with code from a Subversion, Mercurial, or TFS project.

第一次提交代码到GitHub

首先进行初始化配置：设置仓库人员的用户名和邮箱地址，这一步必不可少。

3.入门级接口测试工具:postman的安装

Mon, 28 Aug 2017 04:41:43 +0800

关于postman

postman是跨平台的接口调试及测试工具，非常适合初学者使用。

安装postman

下载地址

请选择相应的版本下载，windows版下载完成后双击安装就好了。

postman的界面

发送第一个请求

我们发送上一节里提到的获取v2ex节点信息的api。

https://www.v2ex.com/api/nodes/show.json?name=python

具体步骤如下

postman是如何工作的

从原理图上可以看出，postman发送请求给服务器，然后从服务器接受响应，最后在postman中展示出来。

服务器响应

上图就是服务器的响应详情，这里包含了一些重要信息

状态码: 200，表示响应是ok的
Body: 返回的主体
Headers: 可以简单的理解为一些键值对，对请求的主体起到了补充的作用
Time: 响应时间
Size: 响应的大小

json字符串

有基础的同学可以看出来，响应的主体是json格式的字符串，那么什么是json格式字符串呢？下一节我们将详细讲解。

原始封面

JMeter官方文档：3. 测试计划中的元素

Thu, 24 Aug 2017 12:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

3.测试计划中的元素（elements of a test plan）

本节描述测试计划不同的部分。

最小测试将包括测试计划、线程组和一个或多个采样器。

3.0 测试计划（Test Plan）

测试计划对象有一个叫 “功能测试” 的复选框，如果选择了，它将导致JMeter记录从服务器返回的每个示例的数据。如果您在测试监听器中选择了一个文件，那么这些数据将被写入文件。如果您正在执行一个小的运行，以确保JMeter的配置正确，并且您的服务器正在返回预期的结果，那么这将非常有用。其结果是，文件将快速增长，JMeter的性能将受到影响。如果您正在进行压力测试(默认情况下是off)，则该选项应该关闭。

如果您没有将数据记录到文件中，则该选项没有任何区别。

您还可以使用侦听器(listener)的配置按钮来决定要保存哪些字段。

3.1 线程组（Thread group）

线程组元素是任何测试计划的起点。所有控制器和采样器必须在线程组下。其他元素，例如侦听器，可以直接置于测试计划之下，在这种情况下，它们将适用于所有的线程组。顾名思义，线程组元素控制JMeter用来执行测试的线程的数量。线程组的控件允许:

Set the number of threads：设置线程数
Set the ramp-up period：设置过渡时期
Set the number of times to execute the test：设置执行测试的次数

每个线程将完全独立地执行测试计划，完全独立于其他测试线程。多个线程用于模拟与服务器应用程序的并发连接。

这个过渡时期告诉JMeter要花多长时间才能“加速”到选择的全部线程数。如果使用10个线程，并且过渡时期是100秒，那么JMeter将花费100秒来启动所有10个线程并运行。在前面的线程开始后，每个线程将开始10(100 / 10)秒。如果有30个线程和一个上升周期120秒，则每个连续线程将延迟4秒。

需要足够长的时间来避免在测试开始时工作负载过大，足够短的时间，最后的线程在第一个线程完成之前就开始运行(除非有人希望发生这样的情况)。从增加的线程数开始，根据需要调整向上或向下。

默认情况下，线程组被配置为通过它的元素循环一次。

线程组还提供了一个 调度器 。单击线程组面板底部的复选框，以启用/禁用额外的字段，在该字段中您可以输入测试持续时间、启动延迟、运行的开始和结束时间。您可以配置 持续时间（秒） 和 启动延迟（秒） 来控制每个线程组的持续时间和启动后的秒数。当开始测试时，JMeter会等待 启动延迟（秒） 之前启动的线程组的线程和运行配置的持续时间（秒）的时间。注意，这两个选项覆盖了 开始时间 和 结束时间 。

或者(尽管不建议不是很灵活)，您可以使用其他两个字段 开始时间 和 结束时间。当测试开始时，JMeter将在必要时等待，直到到达开始时间。在每个循环的末尾，JMeter检查是否已经到达了结束时间，如果是，则停止运行，否则测试将继续运行下去，直到达到迭代限制。

3.2 控制器（Controllers）

JMeter有两种控制器：采样器和逻辑控制器。这些驱动测试的处理。

采样器告诉JMeter发送请求到服务器。例如，如果你想要JMeter发送http请求添加一个HTTP请求取样器。您还可以通过向采样器中添加一个或多个配置元素来定制请求。更多信息，参见：采样器。

appium简明教程（3）——appium的安装windows版

Fri, 18 Aug 2017 07:14:54 +0800

appium的哲学里有一条就是不重新发明轮子。同样，官方已经有明确的安装步骤了，因此在这里纯属搬砖。

原文地址

感谢testerhome的辛勤翻译。

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

限制

如果你在windows上安装appium，你没法使用预编译专用于OS X的.app文件，你也将不能测试IOS apps，因为appium依赖OS X专用的库来支持IOS测试。这意味着你只能通过在mac上来运行IOS的app测试。这点限制挺大。

开始安装

安装nodejs 通过官方的安装程序来安装。
安装android的sdk包，(http://developer.android.com/sdk/index.html), 运行依赖sdk中的’android’工具。并确保你安装了Level17或以上的版本api。设置ANDROID_HOME系统变量为你的Android SDK路径，并把tools platform-tools两个目录加入到系统的Path路径里。因为这里面包含有一些执行命令
安装java的JDK，并设置JAVA_HOME 变量为你的JDK目录。
安装Apache Ant 或者直接使用Android Windows SDK自带的ant，地址在eclipse\plugins目录，你需要把这个目录加到你的系统PATH变量中
安装Apache Maven. 并且设置M2HOME和M2环境变量，把M2环境变量添加到你的系统PATH变量中。
安装Git. 确保你安装了windows下的Git，以便可以运行常用的command命令

现在，你已经下载安装了所有的依赖，开始运行 reset.bat

运行Appium

要在windows上运行测试用例，你需要先启动Android模拟器或者连接上一个API Level17以上的android真机。然后在命令行运行appium node .

备注

你必须带上–no-reset和–full-reset标记，以用于windows上的android
有一个硬件加速模拟器用于android，但是它有自己的一些限制，如果你想了解更多，请参考页面
确保在你的AVD的config.ini中有一个配置项为hw.battery=yes

最简略的安装方式

出于对官方文档的尊重，我按照原文翻译，如下介绍我的安装心得。官方提到的一些工具，其实并不需要安装。下面介绍我已经测试过的安装和使用过程

安装appium

安装nodejs
使用npm安装appium: npm install -g appium

注意：在某些情况下，appium安装的时候并不会把appium的路径放进系统的PATH里，这时候需要手工去加一下。

运行appium

启动appium，直接运行appium 即可。

更新appium

通过npm install -g appium 来更新appium即可

下一节，appium client的安装

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

性能测试基础（三）经典例子--理发店原理

Fri, 11 Aug 2017 13:59:11 +0800

接下来通过一个简单理发店模拟来理解系统的并发处理。

__前提：__

1. 一个理发店有三位理发师傅。

2. 每位理发师傅服务一位顾客需要一小时。

3. 顾客都很忙，从进理发店起最多只能等待三小时（等待加 + 被服务的时间）。

思考：

这里我们来理解“最佳用户数”和“最大用户数”。

最佳用户数：

理发店的最佳状态，理发店收入最多（理发师傅没有休息时间，一直在理发），顾客满意度最高（顾客随时店随时接受服务，无需要等待）。从一个时间点来看，3个理发师傅服务3位顾客，那么这个最佳用户数是3。

最大用户数：

理发店的最大承受状态，理发店收入最多（理发师傅没有休息时间，一直在理发），顾客的最大忍耐度（来的顾客等上三个小时才轮到自己服务）。

假如理发店生意非常好，早上一开门一下子来了一群顾客（很多），A、B、C三位顾客先理，D、E、F顾客需要等待一小时才能得到理发师傅的服务，G、H、I三位顾客等待了两小时才得到服务，后面排队的J、K、L…..等顾客，已经等了三小时还没得到服务，因为这已经得达到了他们等待的极限，所以后他们气愤和无奈离开。

当然，理发店还会不断的来新的顾客，不断有等了三小时而没有得到服务的顾客离开，但对于理发店而言，他们在一个时间点上，能服务的最大用户数是九（三位正在接受服务、三位需要等待1小时，三位需要等待2小时）。

对于最大用户数，需要注意的两点：

1. 在理发店里很大，可以容纳很多位顾客（大于9），总有一部分在这里等待了三小时而没有得到服务离开，不要把等待了3小而没有得到服务的顾客纳入最大用户数里。

2. 假如理发店很小，最多只能容纳六位顾客，当第七个顾客来时，虽然，我们知道他只需要等待2小时就可得到服务（这个时间是他可以接受的范围），但由于理发店容量有量，这第七个顾客只有改天再来了。

关于理发店原理，参考

不知道通过上面对理发店的分析，你对性能有了一些眉目。假如理发店相当于我们的系统的话，顾客就我们向服务器所发送的请求，最佳用户数和最大用户数是我们衡量一个系统的处理能力的一种方法。

原始封面

（三）查看文档

Fri, 11 Aug 2017 07:33:35 +0800

官方文档

官方文档是最权威的参考资料。在绝大多数情况下我们应该首先从官方文档里获取帮助，如果实在是找不到结果，再考虑其他方式。

selenium javascript 版本的文档在这里

stackoverflow

除了官方文档，stackoverflow也是一个非常好的选择，很多时候去一些具体场景的使用问题，这里都有答案。

selenium javascript的问题一般都列在这里，我们可以通过google搜索或者直接在stackoverflow的站内进行搜索。

github

除了浏览源码之外，我们还可以在github上查看selenium的wiki以及查看selenium的已知问题。

如果你想对selenium有进一步的了解，请看这里。

如果你遇到了一些无法解决的问题，不妨在这里搜索一下，可能这是官方的1个bug，在后续的版本中可能有所改进。

原始封面

（三）趣谈软件需求分析

Wed, 26 Jul 2017 12:59:11 +0800

#### 什么是需求分析？

通俗的讲，对用户的意图不断揭示和验叛的过程，要对经过系统可行性分析所确定的系统目标做更为详细的描述。

假如你是个建筑工程师，有个客户找你建一个鸡窝，这个时候要需要与客户沟通，来确定客户到底想要一个什么样子的鸡窝。我们应该注意三点：

1、准确的理解和描述客户需要的功能。

2、帮助客户挖掘需求。

3、分析客户需求的可行性。

#### 需求分析困难在哪儿？

有几种原因使需求分析变得困难：（1）客户说不清楚需求；（2）需求自身经常变动；（3）分析人员或客户理解有误。

1、客户说不清楚需求

2、需求自身经常变动

唐僧曾说：“妖要是有了仁慈之心，就不再是妖，是人妖。”（《大话西游之大圣娶亲》）

连妖都会变心，别说人了。所以喜新厌旧乃人之常情，世界也因此变得多姿多彩。

软件的需求会变化吗？

让我们先接受“需求会变动”这个事实吧，免得在需求变动时惊慌失措。明白“需求会变动”这个道理后，在进行需求分析时就要留点神：

尽可能地分析清楚哪些是稳定的需求，哪些是易变的需求。以便在进行系统设计时，将软件的核心建筑在稳定的需求上，否则将会吃尽苦头。
在合同中一定要说清楚“做什么”和“不做什么”。如果合同含含糊糊，日后扯皮的事情就多。要防止象韩复渠那样，在别人请他喝酒吃饭时他什么都点头（人家就更加献殷勤），吃完了他就宣布刚才答应的事都不算数，便扬长而去。

3、分析人员和顾客理解有误

由于客户大多不懂软件，他们可能觉得软件是万能的，会提出一些无法实现的需求。有时客户还会把软件系统分析人员的建议或答复给想歪了。

#### 需求分析的分类

需求分析一般可分为功能需求、非功能需求和领域需求

1、功能需求

功能需求主要说明了系统实际应做到什么。这是用户最直观也是最主要的需求，如系统的输入输出、系统能完成的功能以及其它相关处理等；

2、非功能需求

非功能需求又称“约束”，它主要从各个角度对系统起约束和限制作用。如响应时间、存储效率、报表的规格和界面的样式等

3、领域需求

#### 如何进行需求分析

进行需求分析不象情人之间的浪漫做法——“让我摸摸你的头发，感觉它是什么颜色。”我们需要了解需求分析的渠道和过程。

需求分析的过程：

（1）可行性研究

（2）需求导出和分析

（3）需求描述

（4）需求有效性验证

主要是通过评审、验证等一系列活动来找出需求文档中的错漏并加以改正。

seleniuim面试题1

Tue, 18 Jul 2017 09:44:38 +0800

selenium中如何判断元素是否存在？

selenium中没有提供原生的方法判断元素是否存在，一般我们可以通过定位元素+异常捕获的方式判断。

# 判断元素是否存在
try:
	dr.find_element_by_id('none')
except NoSuchElementException:
	print 'element does not exist'

selenium中hidden或者是display ＝ none的元素是否可以定位到？

不可以，selenium不能定位不可见的元素。display=none的元素实际上是不可见元素。

selenium中如何保证操作元素的成功率？也就是说如何保证我点击的元素一定是可以点击的？

被点击的元素一定要占一定的空间，因为selenium默认会去点这个元素的中心点，不占空间的元素算不出来中心点;
被点击的元素不能被其他元素遮挡;
被点击的元素不能在viewport之外，也就是说如果元素必须是可见的或者通过滚动条操作使得元素可见;
使用element.is_enabled()(python代码)判断元素是否是可以被点击的，如果返回false证明元素可能灰化了，这时候就不能点;

如何提高selenium脚本的执行速度？

使用效率更高的语言，比如java执行速度就快过python
不要盲目的加sleep，尽量使用显式等待
对于firefox，考虑使用测试专用的profile，因为每次启动浏览器的时候firefox会创建1个新的profile，对于这个新的profile，所有的静态资源都是从服务器直接下载，而不是从缓存里加载，这就导致网络不好的时候用例运行速度特别慢的问题
chrome浏览器和safari浏览器的执行速度看上去是最快的
可以考虑分布式执行或者使用selenium grid

用例在运行过程中经常会出现不稳定的情况，也就是说这次可以通过，下次就没办法通过了，如何去提升用例的稳定性？

测试专属profile，尽量让静态资源缓存
尽量使用显式等待
尽量使用测试专用环境，避免其他类型的测试同时进行，对数据造成干扰

你的自动化用例的执行策略是什么？

每日执行：比如每天晚上在主干执行一次
周期执行：每隔2小时在开发分之执行一次
动态执行：每次代码有提交就执行

自动化测试的时候是不是需要连接数据库做数据校验？

一般不需要，因为这是单元测试层做的事情，在自动化测试层尽量不要为单元测试层没做的工作还债。

id,name,clas,xpath, css selector这些属性，你最偏爱哪一种，为什么？

xpath和css最为灵活，所以其他的答案都不够完美。

如何去定位页面上动态加载的元素？

显式等待

如何去定位属性动态变化的元素？

找出属性动态变化的规律，然后根据上下文生成动态属性。

点击链接以后，selenium是否会自动等待该页面加载完毕？

java binding在点击链接后会自动等待页面加载完毕。

selenium的原理是什么？

selenium的原理涉及到3个部分，分别是

浏览器
driver: 一般我们都会下载driver
client: 也就是我们写的代码

client其实并不知道浏览器是怎么工作的，但是driver知道，在selenium启动以后，driver其实充当了服务器的角色，跟client和浏览器通信，client根据webdriver协议发送请求给driver，driver解析请求，并在浏览器上执行相应的操作，并把执行结果返回给client。这就是selenium工作的大致原理。

webdriver的协议是什么？

client与driver之间的约定，无论client是使用java实现还是c#实现，只要通过这个约定，client就可以准确的告诉drier它要做什么以及怎么做。

webdriver协议本身是http协议，数据传输使用json。

这里有webdriver协议的所有endpoint，稍微看一眼就知道这些endpoints涵盖了selenium的所有功能。

启动浏览器的时候用到的是哪个webdriver协议？

New Session，如果创建成功，返回sessionId和capabilities。

什么是page object设计模式？

官方介绍，简单来说就是用class去表示被测页面。在class中定义页面上的元素和一些该页面上专属的方法。

（三）环境安装之Selenium

Wed, 05 Jul 2017 12:59:11 +0800

### 通过jar包安装

点击 Selenium下载链接你会看到Selenium Standalone Server的介绍：

The Selenium Server is needed in order to run Remote Selenium WebDriver. Selenium 3.X is no longer capable of running Selenium RC directly, rather it does it through emulation and the WebDriverBackedSelenium interface.

Download version 3.4.0

点击版本号进行下载，下载完成将会得到一个__selenium-server-standalone-3.4.0.jar__文件。

或者通过网盘下载。

打开IntelliJ IDEA，导入.jar包。

点击菜单栏 File –> Project Structure（快捷键Ctrl + Alt + Shift + s），点击 Project Structure界面左侧的“Modules” 。在“Dependencies” 标签界面下，点击右边绿色的“+” 号，选择第一个选项“JARs or directories…” ，选择相应的 jar 包，点“OK” ，jar包添加成功。

（三）selenium元素定位

Wed, 28 Jun 2017 07:37:11 +0800

### selenium定位方法

Selenium提供了8种定位方式。

id
name
class name
tag name
link text
partial link text
xpath
css selector

这8种定位方式在Python selenium中所对应的方法为：

find_element_by_id()
find_element_by_name()
find_element_by_class_name()
find_element_by_tag_name()
find_element_by_link_text()
find_element_by_partial_link_text()
find_element_by_xpath()
find_element_by_css_selector()

### 定位方法的用法

假如我们有一个Web页面，通过前端工具（如，Firebug）查看到一个元素的属性是这样的。

<html>
 <head>
 <body link="#0000cc">
 <a id="result_logo" href="/" onmousedown="return c({'fm':'tab','tab':'logo'})">
 <form id="form" class="fm" name="f" action="/s">
 <span class="soutu-btn"></span>
 <input id="kw" class="s_ipt" name="wd" value="" maxlength="255" autocomplete="off">

我们的目的是要定位input标签的输入框。

通过id定位:

dr.find_element_by_id("kw")

通过name定位:

dr.find_element_by_name("wd")

通过class name定位:

dr.find_element_by_class_name("s_ipt")

通过tag name定位:

dr.find_element_by_tag_name("input")

通过xpath定位，xpath定位有N种写法，这里列几个常用写法:

dr.find_element_by_xpath("//*[@id='kw']")
dr.find_element_by_xpath("//*[@name='wd']")
dr.find_element_by_xpath("//input[@class='s_ipt']")
dr.find_element_by_xpath("/html/body/form/span/input")
dr.find_element_by_xpath("//span[@class='soutu-btn']/input")
dr.find_element_by_xpath("//form[@id='form']/span/input")
dr.find_element_by_xpath("//input[@id='kw' and @name='wd']")

通过css定位，css定位有N种写法，这里列几个常用写法:

dr.find_element_by_css_selector("#kw")
dr.find_element_by_css_selector("[name=wd]")
dr.find_element_by_css_selector(".s_ipt")
dr.find_element_by_css_selector("html > body > form > span > input")
dr.find_element_by_css_selector("span.soutu-btn> input#kw")
dr.find_element_by_css_selector("form#form > span > input")

接下来，我们的页面上有一组文本链接。

一个bug的生命周期

Tue, 17 Jun 2025 17:29:15 +0800

又一篇测试技术普及文章，希望你在被各种技术吸引的同时，能时常来整理和总结软件测试最基本的知识。
#### Bug的属性 ---- __Bug重现环境__

这个应该是我们重现bug的一个前提，如果没有这个前提，我们可能会无法重现问题，或者跟本就无从下手。

操作系统

这个是一般软件运行的一大前提，基本上所有的软件都依赖于操作系统之上的，对于一个软件来说，要想在某个操作系统上运行，必须要对这个操作系统支持，这就需要有真对性的设计与开发。对于不同的操作系统，其可能存在差异（如：win xp 与 win 7）或本质的区别（如 win 7 与 CentOS linux ），所以，操作系统环境是重现问题的一个重要前提。

浏览器

对于B/S系统，或面向大众的互联网产品（网站，邮箱等），浏览器的兼容性也是必须测试的一个重点，对于现在的浏览器市场，各式的浏览器都有其用户群，要想使产品大众化，必须考虑这些产品的兼容性问题。

不同的浏览器之间（IE、 firefox、chrome、opera 等），甚至同一系列不同版本（ie6/ie7/ie8/ie9等）都可能存在兼容性问题，所以，对于这类应用，浏览器环境重现bug前提条件之一。

其它（这个“其它”非常重要）

对于不同的系统发现重现问题，都会有其特定的前提，拿我测试的邮箱来说，必须要描述其是在测试线还是现网环境，而且还要附带一重现问题的帐号等。

对于c/s软件，可能还要考虑与其它常用软的兼容等，例如，是在安装的某款软件后，对本软件的安装和使用造成影响。这些都是重现问题的必须描述的环境。

问题类型

根据JIRA的管理系统的划分，bug 只是问题的一种，它可以用于跟踪多种不同类型的问题（其实，他只是将bug做为一子类而已）。

JIRA系统缺省提供的问题类型（大部分的系统都可以自定义类型的，这样就增加了灵活性。）

Bug : 测试过程、维护过程发现影响系统运行的缺陷。（这就是一般测试人员所提交的bug）
New Feature : 对系统提出的新功能。（单个的小需求可以，如果大的话，就相当于一个需求，放到这里是不合理的。）
Task : 需要完成的一任务。（开发或测试任务指派。）
Improvement : 对现有系统功能的改进。（一般产品经理或产品体验师做的事）

当然，不同的公司，他们的人员定位与职责是不太相同的，按照上面的分类，JIRA就不是简单的缺陷管理系统了，它涵盖一项目（或产品）所需要处理的任务、需求与缺陷。

Bug 类型

这里缩小范围，单指我们测试人员在测试过程中发现的缺陷，发现产品缺陷其实就是测试人员工作的主要目的。当然，你要确定一个问题的类型，也需要对项目（或产品）有比较深的理解。是代码缺陷还是设计缺陷有时候就不太容易区分，当然，这个划分，对于开发定位问题影响很小，但对于问题类型的统计就比较重要了。

下面看一些常见的分类：

划分方式一：

　　* 代码错误

　　* 设计缺陷

　　* 界面优化

　　* 配置相关

　　* 安装部署

 * 性能问题

　　* 标准规范

　　* 测试代码

　　* 其它

划分方式二：

　　* 功能类（function）

　　* 性能类（performance）

　　* 界面类（UI）

　　* 易用性类（usability）

　　* 兼容性类（compatibility）

　　* 其它（else）

这个分类当然是可以自定义的，具我接触的缺陷管理都是可以自定义的，既然是对问题的管理，那么你当然可以拿来做特定环境下的系统来使用，或我就想用这个系统来指派任务，那么我的自定义类型为前端任务、后端任务、测试任务、配置部署…

wrk系列教程(4)常用参数

Sun, 03 Mar 2019 02:00:11 +0800

这一节我们看一下wrk常用的命令行参数。

-c, --connections: HTTP连接数的总量。对于每一个线程，保持的连接数N
 N = connections/threads

-d, --duration: 测试运行时间, e.g. 2s, 2m, 2h

-t, --threads: 总的线程数

-s, --script: lua脚本，后面会讲

-H, --header: 设置请求的HTTP header, e.g. "User-Agent: wrk"

 --latency: 打印详细的时延统计

 --timeout: 如果请求的timeout的时间内没有响应，那么就记录1个timeout

具体例子

10个线程100个连接跑1个小时

wrk -t10 -c100 -d1h www.example.com

10个线程100个连接跑1个小时，请求的响应超时时间设置为1s

wrk -t10 -c100 -d1h --timeout=1s www.example.com

模拟ios上的safari浏览器 10个线程100个连接跑1个小时

wrk -t10 -c100 -d1h --header="User-agent: Mozilla/5.0 (iPhone; CPU iPhone OS 11_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1" www.example.com

原始封面

python简明教程: 4. 函数

Mon, 19 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 4. 函数
####################################################

# 用"def" 来定义函数
def add(x, y):
 print "x is {0} and y is {1}".format(x, y)
 return x + y # 用return语句来从函数中返回具体的值


# 调用函数并传入参数
add(5, 6) # => 打印出 "x is 5 and y is 6" 并返回 11

# 另一种调用函数的方式，使用关键字参数
add(y=6, x=5) # 使用关键字参数的话，参数出现的顺序是可以随意的


# 可以定义不定长的固定位置参数
# 使用 * 加参数名的形式
# 参数将被解析成元组
def varargs(*args):
 return args


varargs(1, 2, 3) # => (1, 2, 3)


# 可以定义不定长的关键字参数
# 使用 * 加参数名的形式
# 参数将被解析成字典
def keyword_args(**kwargs):
 return kwargs


# 调用一下看会发生什么
keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}


# 也可以将两种方式结合起来使用
def all_the_args(*args, **kwargs):
 print args
 print kwargs


"""
all_the_args(1, 2, a=3, b=4) prints:
 (1, 2)
 {"a": 3, "b": 4}
"""

# 调用函数的时候其实就是对args/kwargs做反向操作
# 使用 * 来展开固定位置参数args, 使用 ** 去展开关键字参数kwargs
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # 等于是调用了 foo(1, 2, 3, 4)
all_the_args(**kwargs) # 等于 foo(a=3, b=4)
all_the_args(*args, **kwargs) # 等于 foo(1, 2, 3, 4, a=3, b=4)


# 你可以将函数参数里的args/kwargs传到其他函数里去
# 分别使用 * 和 **
def pass_all_the_args(*args, **kwargs):
 all_the_args(*args, **kwargs)
 print varargs(*args)
 print keyword_args(**kwargs)


# 函数作用域
x = 5


def set_x(num):
 # 本地变量x跟全局变量x的值是不一样的，尽管同名
 x = num # => 43
 print x # => 43


def set_global_x(num):
 global x
 print x # => 5
 x = num # 全局变量 x 现在被设为 6
 print x # => 6


set_x(43)
set_global_x(6)


# Python has first class functions
def create_adder(x):
 def adder(y):
 return x + y

 return adder


add_10 = create_adder(10)
add_10(3) # => 13

# 这是匿名函数
(lambda x: x > 2)(3) # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5

# 这是内置的高阶函数
map(add_10, [1, 2, 3]) # => [11, 12, 13]
map(max, [1, 2, 3], [4, 2, 1]) # => [4, 2, 3]

filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]

# 可以使用列表表达式去实现优雅的maps和filters
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]

# 也可以用字典表达式来构造集合和字典
{x for x in 'abcddeef' if x in 'abc'} # => {'a', 'b', 'c'}
{x: x ** 2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

原始封面

（四）Docker 容器

Mon, 22 Jan 2018 14:42:11 +0800

简单的说，容器是独立运行的一个或一组应用，以及它们的运行态环境。如果把镜像看成面向对象中的类的话，那么容器就是类的实例化对象。

容器

启动容器

启动容器有两种方式，一种是基于镜像新建一个容器并启动，另外一个是将在终止状态（stopped）的容器重新启动。

通过docker run 命令来启动容器。

查看运行帮助：

$ sudo docker run --help

下面的命令输出一个 “Hello World”，之后终止容器。

$ sudo docker run ubuntu /bin/echo "hello world"
hello world

这跟在本地直接执行 /bin/echo 'hello world'几乎感觉不出任何区别。只不过，这里的输入是由通过 ubuntu 容器执行。

下面进入到ubuntu容器中。

$ sudo docker run -t -i ubuntu /bin/bash
root@543a324ea841:/#

-t 选项让Docker分配一个伪终端（pseudo-tty）并绑定到容器的标准输入上。
-i 则让容器的标准输入保持打开。

此时，你已经在ubuntu容器中了。这是一个独立的ubuntu 系统。通过 root@543a324ea841 标识可以看出。

当利用docker run 来创建容器时，Docker在后台运行的标准操作包括：

检查本地是否存在指定的镜像，不存在就从公有仓库下载
利用镜像创建并启动一个容器
分配一个文件系统，并在只读的镜像层外面挂载一层可读写层
从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
从地址池配置一个IP地址给容器
执行用户指定的应用程序
执行完毕后容器被终止

退出容器，可以使用exit命令。

root@543a324ea841:/# exit 
exit
fnngj@ubuntu:~$

守护状态运行

更多的时候，需要让 Docker容器在后台以守护态（Daemonized）形式运行。

（四）Java的三种基本结构

Wed, 17 Jan 2018 14:40:11 +0800

结构化编程的三种基本结构？你可能会犹豫一下，它们分别是：

顺序结构
分支结构
循环结构

大学学过 C 语言的同学一下就明白了，具我接触过的编程语言都提供的了这三种基本结构，不管是面向过程的编程语言，还是面向对象的编程语言。

顺序结构 表示程序中的各操作是按照它们出现的先后顺序执行的。

分支结构 表示程序的处理步骤出现了分支，它需要根据某一特定的条件选择其中的一个分支执行。

循环结构 表示程序反复执行某个或某些操作，直到某条件为假（或为真）时才可终止循环。

分支与循环例子

求数的阶乘，如下：

0！=1
1！=1
2！=2×1=2
3！=3×2×1=6

实现代码如下：


public class JavaStructure {

 public static void main(String[] args) {

 // 计算10人的阶乘
 int number = 10;

 // 0和1的阶乘都为1
 if (number == 0 || number == 1) {
 System.out.print(1);
 }else {
 //循环累乘 10
 int count = 1;
 for (int i = number; i > 0; i--) {
 count *= i;
 }
 System.out.print(count);
 }

 }
}

打印一个三角形，如下：


 *
 ***
 *****
 *******
*********

实现代码如下：

TDD实战（四）“井字游戏” 需求三

Mon, 08 Jan 2018 12:50:11 +0800

需求3

现在考虑这个游戏的获胜规则，这部分工作会比较麻烦。我们必须检查所可能获胜的情况，只要满足其中一个，就宣布相应玩家获胜。

最先在水平、锤直或对角线上将自己的3个标记连起来的玩家获胜。

测试用例1

首先定义play() 的默认返回值：


@Test
public void whenPlayThenNoWinner(){
 String actual = ticTacToe.play(1,1);
 assertEquals("No winner", actual);
}

如果不满足获胜条件，则无人获胜。

实现代码1

这个用例很容易满足，修改 play() 方法如下：


public String play(int x, int y){
 checkAxis(x);
 checkAxis(y);
 setBox(x, y);
 lastPlayer = nextPlayer();
 return "No winner";
}

** 执行测试用例1 检查它是否运行通过。

测试用例2

处理各种获胜条件。

@Test
public void whenPlayAndWholeHorizontalLineThenWinner(){
 ticTacToe.play(1,1); //X
 ticTacToe.play(1,2); //O
 ticTacToe.play(2,1); //X
 ticTacToe.play(2,2); //O
 String actual = ticTacToe.play(3, 1); //X
 assertEquals("X is the winner", actual);
}

X 玩家最新占满一条水平线，所以 X 玩家获胜。

Android测试（四）：Local 单元测试

Wed, 20 Dec 2017 14:40:12 +0800

原文：https://developer.android.com/training/testing/unit-testing/local-unit-tests.html

如果你的单元测试没有依赖或者只有简单的Android依赖，则应该在本地开发机器上运行测试。这种测试方法非常高效，因为它可以帮助你避免每次运行测试时将目标应用程序和单元测试代码加载到真机或模拟器上的开销。因此，运行单元测试的执行时间大大减少了。通过这种方法，你通常使用mock框架（如Mockito）来完成任何依赖关系。

设置测试环境

在你的Android Studio项目中，必须将本地单元测试的源文件存储在module-name/src/test/java/ 目录中。在创建新项目时，该目录已经存在。

你还需要配置项目的测试依赖，以使用JUnit 4框架提供的标准API。如果你的测试需要与Android依赖关系进行交互，请包含Mockito库以简化本地单元测试。要了解有关在本地单元测试中使用模拟对象的更多信息，请参阅模拟Android依赖关系。

在你的App程序的目录下找到build.gradle文件中，将这些库指定为依赖项：

dependencies {
    // Required -- JUnit 4 framework
    testCompile 'junit:junit:4.12'
    // Optional -- Mockito framework
    testCompile 'org.mockito:mockito-core:1.10.19'
}

创建本地单元测试类

你的本地单元测试类应该写成一个JUnit 4测试类。 JUnit是Java最流行和广泛使用的单元测试框架。这个框架的最新版本，JUnit 4，允许你用比前一版本更清晰，更灵活的方式编写测试。与以前的基于JUnit 3的Android单元测试方法（使用JUnit 4）不同，你不需要扩展junit.framework.TestCase类。也不需要在测试方法名称前加上“test”关键字，或者使用junit.framework或junit.extensions包中的任何类。

要创建基本的JUnit 4测试类，请创建一个包含一个或多个测试方法的Java类。测试方法从@Test注释开始，包含代码来练习和验证要测试的组件中的单个功能。

以下示例显示了如何实现本地单元测试类。测试方法emailValidator_CorrectEmailSimple_ReturnsTrue验证被测试的应用程序中的isValidEmail()方法是否返回正确的结果。

import org.junit.Test;
import java.util.regex.Pattern;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class EmailValidatorTest {

    @Test
    public void emailValidator_CorrectEmailSimple_ReturnsTrue() {
        assertThat(EmailValidator.isValidEmail("name@email.com"), is(true));
    }
    ...
}

要测试应用程序中的组件是否会返回预期的结果，请使用junit.Assert方法执行验证检查（或断言），以便将待测组件的状态与某个预期值进行比较。为了使测试更具可读性，可以使用Hamcrest匹配器（如is（）和equalTo（）方法）将返回的结果与期望的结果进行匹配。

Fiddler（四）设置代理 HTTPS 请求

Tue, 19 Dec 2017 13:50:11 +0800

HTTPS 介绍

HTTPS（全称：Hyper Text Transfer Protocol over Secure Socket Layer），是以安全为目标的HTTP通道，简单讲是HTTP的安全版。

HTTPS在HTTP的基础上加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密。

HTTPS和HTTP的区别主要为以下四点：

一、https协议需要到ca申请证书，一般免费证书很少，需要交费。

二、http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议。

三、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

四、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

Fiddler设置HTTPS代理

1、打开Fiddler，菜单栏：Tools –> Fiddler Options 打开fiddler配置。

2、打开 HTTPS 配置项，勾选“Capture HTTPS CONNECTs”和“Decrypt HTTPS traffic”，然后点击“OK”。

重启Fiddler，就可以实现HTTPS请求的代理了。

原始封面

层级遍历:获取所有的热门主题

Fri, 15 Dec 2017 02:52:34 +0800

稍微复杂一点的例子

在v2ex主页的右侧一般有个最热主题区域，里面列出了当日的热门讨论话题。这一节里我们就尝试使用爬虫技术获取这些热门主题文本和链接。

注意：v2ex本身提供了接口去获取这些热门主题的详细信息，本节内容只是举例，并不是最佳实践

具体步骤

访问v2ex主页，获取html文本
分析html文本，找出待获取内容的特征
解析html代码，根据特征拿出目标内容
打印这些内容

分析html代码

热门内容部分的html代码如下所示

<span class="item_hot_topic_title">
 <a href="/t/415664">冬天了，身上静电咋处理？</a>
</span>

可以看出我们要找到的是所有class=item_hot_topic_title的span下面的a元素

代码

新建名为v2ex_hosts.py的文件，输入下面的内容


import requests
from bs4 import BeautifulSoup

url = 'https://www.v2ex.com/'
soup = BeautifulSoup(requests.get(url).text, 'html.parser')

for span in soup.find_all('span', class_='item_hot_topic_title'):
 print(span.find('a').text, span.find('a')['href'])

运行

在命令行中输入

python v2ex_hosts.py

预期结果

如果一切正常，那么应该可以看到类似下面的结果，由于每天的热门主题不一样，所以内容是会变化的

小米感恩节不感恩 /t/415623
冬天了，身上静电咋处理？ /t/415664
违反一下政治正确，骂一下 Google /t/415600
做了将近 6 年程序员，没能成为大牛，考虑再三，决定改行，大家说，做点什么好呢？ /t/415701
结果还是被雷猴王给套路了 /t/415843
一直很好奇 Mac+安卓的组合是基于什么优势考虑的呢？ /t/415645
听说比特币要分叉了？ /t/415858
看到大学同学朋友圈发的北大成人通知书，心里不是滋味。 /t/415821
当码农 8 年了，要不要去读个研 /t/415854
新进一家公司遭遇的待遇~~ /t/415863

我们可以学到什么

for span in soup.find_all('span', class_='item_hot_topic_title'): 遍历所有的class=item_hot_topic_title的span。注意是class_，不是class，因为class是python的关键字，所以后面要加个尾巴，防止冲突
span.find('a').text：层级遍历，先找到span，再从span下找到a，这是常用套路
span.find('a')['href']：获取href属性，在bs4里，我们可以通过[attribute_name]的方式来获取元素的属性

阅读内容

BeautifulSoup

原始封面

（四）参数匹配器 (matchers)

Sat, 25 Nov 2017 12:50:11 +0800

参数匹配器 (matchers)

Mockito以自然的java风格来验证参数值: 使用equals()函数。有时，当需要额外的灵活性时你可能需要使用参数匹配器，也就是argument matchers : 例子

import org.junit.Test;

import java.util.LinkedList;

import static org.mockito.Mockito.*;



public class MockitoDemo {

 @Test
 public void with_arguments(){

 LinkedList mockedList = mock(LinkedList.class);

 //stubbing using built-in anyInt() argument matcher
 // 使用内置的anyInt()参数匹配器
 when(mockedList.get(anyInt())).thenReturn("element");

 //following prints "element"
 // 输出element
 System.out.println(mockedList.get(1));

 //you can also verify using an argument matcher
 // 你也可以验证参数匹配器
 verify(mockedList).get(anyInt());
 }
}

参数匹配器使验证和测试桩变得更灵活。点击这里查看更多内置的匹配器以及自定义参数匹配器或者hamcrest 匹配器的示例。

（四）testng.xml文件解析

Sat, 25 Nov 2017 12:45:11 +0800

TestNG 与 Junit 比较大的一个差异就是前者通过 testng.xml 文件来配置测试用例的执行。 testng.xml文件可以很好的控制要执行的测试用例的粒度，及各种运行策略。

目前testng.xml DTD（Document Type Definition; DTD是一种XML的约束方式。）配置说明可以在：这里

testng.mxl 文件解析

<suite name="Suite1" verbose="1" >
 <test name="Nopackage" >
 <classes>
 <class name="NoPackageTest" />
 </classes>
 </test>

 <test name="Regression1">
 <classes>
 <class name="test.sample.ParameterSample"/>
 <class name="test.sample.ParameterTest"/>
 </classes>
 </test>
</suite>

<suite>...</suite> 表示定义了的一个测试套件。
- name 定义测试套件的名称。
- verbose 定义命令行信息打印等级，不会影响测试报告输出内容；可选值(1|2|3|4|5)
<test>...</test> 表示定义了一个测试。
- name 定义测试的名称。
<classes>...</classes> 表示定义一组测试类。
<class .../> 表示定义一个测试类。
- name 指定要运行的测试类

实例

测试项目目录结果如下：

testng.mxl 配置文件如下：

（四）通过 mvn 命令创建 Maven 项目

Sat, 25 Nov 2017 12:40:11 +0800

通过 mvn 命令创建项目

Maven官方文档：Maven Getting Started Guide

通过 mvn 命令创建一个 Maven 项目。

mvn -B archetype:generate \
 -DarchetypeGroupId=org.apache.maven.archetypes \
 -DgroupId=com.mycompany.app \
 -DartifactId=my-app

-B ：该参数表示让Maven使用批处理模式构建项目，能够避免一些需要人工参与交互而造成的挂起状态。
archetype:generate : 创建 Maven 项目的命令。
DarchetypeGroupId ：指定 Apache maven 组织名。
DgroupId ：指定项目或公司组名。
DartifactId ：指定项目名。

例如：

mvn -B archetype:generate -DgroupId=com.myapp.pro -DartifactId=myapp -DarchetypeArtifactId==maven-archetype-quickstart -DinteractiveMode=false

将，该命令复制到 Windows 命令提示符（Linux 终端）下执行。

继续通过mvn idea:idea命令生成 IntelliJ IDEA 项目工程。

> cd myapp\

..\myapp> mvn idea:idea

然后，通过 IntelliJ-IDEA 打开 myapp 项目。

requests如何发送其他请求

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

delete,options,put等类型的请求在requests中均有对应的方法

>>> r = requests.put('http://httpbin.org/put', data = {'key':'value'})
>>> r = requests.delete('http://httpbin.org/delete')
>>> r = requests.head('http://httpbin.org/get')
>>> r = requests.options('http://httpbin.org/get')

也可以使用requests统一的request方法来发送各种请求

r = requests.request('get', 'https://api.github.com/events')
>>> r = requests.request('post', 'http://httpbin.org/post', data = {'key':'value'})
>>> r = requests.request('put', 'http://httpbin.org/put', data = {'key':'value'})
>>> r = requests.request('delete', 'http://httpbin.org/delete')
>>> r = requests.request('head', 'http://httpbin.org/get')
>>> r = requests.request('options', 'http://httpbin.org/get')

原始封面

（四）JUnit 注解

Mon, 13 Nov 2017 12:45:11 +0800

JUnit 注解

JUnit 注解说明：

注解	说明
@Test：	标识一条测试用例。 (A) (expected=XXEception.class) (B) (timeout=xxx)
@Ignore:	忽略的测试用例。
@Before:	每一个测试方法之前运行。
@After :	每一个测试方法之后运行。
@BefreClass	所有测试开始之前运行。
@AfterClass	所有测试结果之后运行。

例子

创建被测试类 Count .

public class Count {

 /**
 * 计算并返回两个参数的和
 */
 public int add(int x ,int y){
 return x + y;
 }

 /**
 * 计算并返回两个数相除的结果
 */
 public int division(int a, int b){
 return a / b;
 }
}

创建测试类 CountTest .

4. 实例: 读取测试数据并测试弱密码

Tue, 07 Nov 2017 06:23:31 +0800

背景

接上一节的弱密码例子，我们的用例尽管运行的不错，但还是有点问题。

假如我们需要增加一些测试数据，那么我们就必须去修改setUp方法，在test_data列表中增加数据，频繁修改代码以适应一些不变的测试场景，这是没有必要的开销，可以想办法去优化。

我们可以把测试数据保存在文件里，通过读取文件的方式，每次动态从测试用例读取数据，这样数据的改变并不会影响用例，用例逻辑相对稳定，维护成本得到一定的降低。

设计测试数据

我们可以把测试数据保存成json格式，json格式的数据在各个语言间有较好的通用性，比较适合复用。

新建user_data.json文件，内容如下

[
 {"name":"jack","password":"Iloverose"},
 {"name":"rose","password":"Ilovejack"},
 {"name":"tom","password":"password123"}
]

使用python的json库解析上面的json文件，可以得到如上节中test_data一致的数据。

代码

新建test_password_2.py，内容如下

import unittest
import json

class PasswordWithJsonTeseCase(unittest.TestCase):
 data_file_path = './user_data.json'

 def setUp(self):
 print('set up')
 self.test_data = json.loads(open(self.data_file_path).read())

 def test_week_password(self):
 for data in self.test_data:
 passwd = data['password']

 self.assertTrue(len(passwd) >= 6)

 msg = "user %s has a weak password" %(data['name'])
 self.assertTrue(passwd != 'password', msg)
 self.assertTrue(passwd != 'password123', msg)

 def test_dummy(self):
 pass

if __name__ == '__main__':
 unittest.main()

跟上一节相比，最大的不同点是现在test_data通过解析json文件的方式来赋值self.test_data = json.loads(open(self.data_file_path).read())。

执行测试文件，结果应该与上一节一致。

发现问题

上面的代码有2个测试方法:test_week_password和test_dummy。由于setUp会在每个测试方法执行之前执行一次，那么setUp方法会执行2次，相应的json文件也会读取2次。如果测试方法多的话，那么反复读取json文件对性能来说是一个巨大的挑战。

优化

对于上面的测试数据读取场景，我们可以在所有测试方法执行前读取一次数据，毕竟测试数据在所有测试方法执行过程中是保持不变的。

setUpClass()和tearDownClass()

setUpClass方法在每个测试用例类执行之前会执行一次，接收该class作为唯一的参数，并且必须使用装饰器classmethod()
tearDownClass: 在所有测试方法执行完之后被调用1次，调用方式跟上面的方法类似

重构

下面我们重构代码以达到只读取1次测试数据的目的，新建文件````test_password_3.py```，内容如下

import unittest
import json

class WeakPasswordTeseCase(unittest.TestCase):

 @classmethod
 def setUpClass(kls):
 data_file_path = './user_data.json'
 print('before all test methods')
 with open(data_file_path) as f:
 kls.test_data = json.loads(f.read())

 def test_week_password(self):
 for data in self.test_data:
 passwd = data['password']

 self.assertTrue(len(passwd) >= 6)

 msg = "user %s has a weak password" %(data['name'])
 self.assertTrue(passwd != 'password', msg)
 self.assertTrue(passwd != 'password123', msg)

 def test_dummy(self):
 pass

if __name__ == '__main__':
 unittest.main()

有几点需要提及一下

4. 变量和名称

Sat, 04 Nov 2017 08:17:22 +0800

背景

变量是编程语言中常见的概念。变量实际上很简单，我们可以把它想象成是一个盒子，这个盒子有名字，就是变量名，盒子里面可以放东西进去，就是变量的值。

程序员们一般使用变量让代码变得更加容易理解，因为他们的记忆力很糟糕，所以如果不取一些有意义的变量名的话，他们后来可能就看不懂自己写的代码了。

我们对上一节的内容稍微做一些修改，加入变量的实践。

代码实现

新建名为report_with_var.py，内容如下

# 打印出本次测试的测试结果
# A: 27/30 B: 40/40 C: 30/30
module_count = 3

case_count_of_module_a = 30.0
success_case_count_of_module_a = 27

case_count_of_module_b = 40.0
success_case_count_of_module_b = 40

case_count_of_module_c = 30.0
success_case_count_of_module_c = 30

print('本次测试覆盖了',module_count ,'个模块')
print('测试用例总数为: ', case_count_of_module_a + case_count_of_module_b + case_count_of_module_c)
print('执行的测试用例总数为: ', case_count_of_module_a + case_count_of_module_b + case_count_of_module_c)
print('用例最多的模块是B模块，B模块比A模块多出的用例数为', case_count_of_module_b - case_count_of_module_a)
print('A模块执行成功', success_case_count_of_module_a, '个用例，执行失败的用例数为', case_count_of_module_a - success_case_count_of_module_a)
print('A模块用例通过率为百分之', success_case_count_of_module_a / case_count_of_module_a * 100)
print('B模块的用例全部执行通过， 通过率为百分之', (success_case_count_of_module_b / case_count_of_module_b) * 100)
print('C模块的用例全部执行通过， 通过率为百分之', (success_case_count_of_module_b / case_count_of_module_b) * 100)
print('B模块的用例比C模块多吗?', case_count_of_module_b > case_count_of_module_c)
print('A模块的用例比C模块多吗?', case_count_of_module_a > case_count_of_module_c)
print('B模块的用例比C模块少吗?', case_count_of_module_b < case_count_of_module_c)

# 结束打印
print('回归不通过')

运行

在命令行中使用下面的命令去执行代码

$python report_with_var.py

你应该可以看到

如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

本次测试覆盖了 3 个模块
测试用例总数为: 100.0
执行的测试用例总数为: 100.0
用例最多的模块是B模块，B模块比A模块多出的用例数为 10.0
A模块执行成功 27 个用例，执行失败的用例数为 3.0
A模块用例通过率为百分之 90.0
B模块的用例全部执行通过， 通过率为百分之 100.0
C模块的用例全部执行通过， 通过率为百分之 100.0
B模块的用例比C模块多吗? True
A模块的用例比C模块多吗? False
B模块的用例比C模块少吗? False
回归不通过

动手时间

刚开始写代码的时候，我们经常会敲错，比如

4.Fixture

Tue, 31 Oct 2017 07:22:42 +0800

我们可以简单的把Fixture理解为准备测试数据和初始化测试对象的阶段。

一般我们对测试数据和测试对象的管理有这样的一些场景

所有用例开始之前初始化测试数据或对象
所有用例结束之后销毁测试数据或对象
每个用例开始之前初始化测试数据或对象
每个用例结束之后销毁测试数据或对象
在每个／所有module的用例开始之前初始化数据或对象
在每个／所有module的用例开始之后销毁数据或对象
……
……

pytest的fixture特性可以满足上面的需求。

简单的例子

考虑这种场景，我们需要判断用户的密码中包含简单密码，规则是这样的，密码必须至少6位，满足6位的话判断用户的密码不是password123或者password之类的弱密码。

我们将用户的信息导出成名为users.dev.json的文件，该文件如下所示

[
 {"name":"jack","password":"Iloverose"},
 {"name":"rose","password":"Ilovejack"},
 {"name":"tom","password":"password123"}
]

新建名为test_user_password.py的文件，键入以下内容，一定要保证users.dev.json文件与该文件在同一路径下

import pytest
import json

class TestUserPassword(object):
 @pytest.fixture
 def users(self):
 return json.loads(open('./users.dev.json', 'r').read()) # 读取当前路径下的users.dev.json文件，返回的结果是dict

 def test_user_password(self, users):
 # 遍历每条user数据
 for user in users:
 passwd = user['password']
 assert len(passwd) >= 6
 msg = "user %s has a weak password" %(user['name'])
 assert passwd != 'password', msg
 assert passwd != 'password123', msg

运行

pytest可以通过指定文件名的方式运行单个用例文件，这里我们只运行test_user_password.py文件

pytest test_user_password.py

运行结果

$ pytest test_user_password.py
========================================================================= test session starts =========================================================================
platform darwin -- Python 2.7.12, pytest-3.2.3, py-1.4.34, pluggy-0.4.0
rootdir: /Users/easonhan/code/testclass.net/src/pytest, inifile:
collected 1 item

test_user_password.py F

============================================================================== FAILURES ===============================================================================
_________________________________________________________________ TestUserPassword.test_user_password _________________________________________________________________

self = <test_user_password.TestUserPassword object at 0x1046e3290>
users = [{'name': 'jack', 'password': 'Iloverose'}, {'name': 'rose', 'password': 'Ilovejack'}, {'name': 'tom', 'password': 'password123'}]

 def test_user_password(self, users):
 for user in users:
 passwd = user['password']
 assert len(passwd) >= 6
 msg = "user %s has a weak password" %(user['name'])
 assert passwd != 'password', msg
> assert passwd != 'password123', msg
E AssertionError: user tom has a weak password
E assert 'password123' != 'password123'

test_user_password.py:14: AssertionError
====================================================================== 1 failed in 0.03 seconds =======================================================================

分析

使用@pytest.fixture装饰器可以定义feature
在用例的参数中传递fixture的名称以便直接调用fixture，拿到fixture的返回值
3个assert是递进关系，前1个assert断言失败后，后面的assert是不会运行的，因此重要的assert放到前面
E AssertionError: user tom has a weak password可以很容易的判断出是哪条数据出了问题，所以定制可读性好的错误信息是很必要的
任何1个断言失败以后，for循环就会退出，所以上面的用例1次只能发现1条错误数据，换句话说任何1个assert失败后，用例就终止运行了

执行顺序

pytest是这样运行上面的用例的

4. Finds

Thu, 26 Oct 2017 06:55:26 +0800

webium.find.Finds 方法的用法跟Find方法基本是一致的，不过返回的是WebElement列表。

from selenium.webdriver.common.by import By
from webium import BasePage, Finds

class LinksPage(BasePage):
 links = Finds(by=By.TAG_NAME, value='a')

 def __init__(self):
 super(LinksPage, self).__init__(url='http://itest.info')


if __name__ == '__main__':
 page = LinksPage()
 page.open()
 print('Number of links: ' + str(len(page.links)))

我们甚至可以动态返回满足条件的一组元素。

from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
from webium import BasePage, Finds


class Link(WebElement):
 def is_secure(self):
 return self.get_attribute('href').startswith('https://')


class TypedPage(BasePage):
 links = Finds(Link, By.TAG_NAME, 'a')

 def __init__(self):
 super(TypedPage, self).__init__(url='http://itest.info')

 def get_unsecured_links(self):
 return filter(lambda link: not link.is_secure(), self.links)


if __name__ == '__main__':
 page = TypedPage()
 page.open()
 print('Number of unsecured links: ' + str(len(page.get_unsecured_links())))

原始封面

收藏清单: python安全测试API测试及性能测试最全资源汇总

Mon, 23 Oct 2017 08:19:06 +0800

REST API Testing REST API测试

Rester - 测试RESTful API的框架
pyresttest - REST以及API microbenchmarking工具
siesta - Python REST 客户端

Virtual environments 虚拟环境

virtualenv - 创建隔离的python开发环境的工具
virtualenvwrapper - virtualenv的一些扩展
tox - 虚拟环境管理，可以在不同的python版本上进行测试和截图
pew - 一些管理虚拟环境的工具
Vex - 在命名的虚拟环境运行命令
PyRun - 单文件无需按照的python版本
pyenv - 简单的python版本管理
Tapper - all-embracing test infrastructure.

Performance & stress & load 性能测试

Multi-Mechanize - 开源的性能测试框架
locust - 可扩展的python性能测试工具
Yandex.Tank - 性能及benchmark工具
pytest-benchmark - py.test的benchmark工具
Airspeed Velocity - 简单的Python benchmarking工具自带基于web的报告
The Grinder - 支持分布式的负载测试框架. 包含一些常规用例，比如 HTTP web servers, SOAP and REST web services, 和 application servers (CORBA, RMI, JMS, EJBs),以及定制化的协议. 测试脚本使用Jython和Clojure实现
Tsung - 开源，支持多协议的分布式性能测试工具. 可以测试 HTTP, WebDAV, SOAP, PostgreSQL, MySQL, LDAP 和 Jabber/XMPP 服务
taurus - 自动化友好的持续测试工具

Security checking 安全扫描

sparta - 支持gui的网络扫描工具
OWASP ZAP - 用python实现的OWASP ZAP-features API
pythem - pythem是多用途的安全测试工具

原始封面

（四）Jenkins 配置构建执行状态

Mon, 16 Oct 2017 13:00:11 +0800

运行构建

在项目左侧列表点击 “立即构建” ，在 “Build History” 列表，你会得到一个红色的小圆点，表示构建失败。

点击构建失败的任务（红色的小圆点）。然后点击“Console Output” 就可以查看失败的 log 了。

提示： 'python' 不是内部或外部命令，也不是可运行的程序或批处理文件。

我们明明在 Windows 提示符下运行是没有问题的。这是因为 Jenkins 缺少环境配置。

配置构建执行状态

回到 Jenkins 首页，点击 “构建执行状态” ,右则会列出本机信息，点击本机信息，配置 Python 的 path 环境变量。同时还需要添加浏览器驱动文件所在目录，参考。

如果你明白这块的话，说明你不懂 Python 语言，或不熟悉 Python 运行环境的配置。（不同技术的之间的配合使用存在一定的依赖关系！我们无法做到零基础。）

配置完成，点击 “保存” , 再来运行 “立即构建” ，这次看到 py_tests.py 自动化脚本被执行了。

（四）Locust no-web模式

Mon, 16 Oct 2017 12:00:11 +0800

熟悉 Apache ab 工具的同学都知道，它是没有界面的，通过命令行执行。 Locust 同样也提供的命令行运行，好处就是更节省客户端资源。

命令行运行 Locust 测试

以上一节的 baidu 首页测试（load_test.py）为例通过 no-web 模式运行测试。

> locust -f load_test.py --host=https://www.baidu.com --no-web -c 10 -r 2 -t 1m

[2017-10-30 22:17:30,292] DESKTOP-SMGQBBM/INFO/locust.main: Run time limit set to 60 seconds
[2017-10-30 22:17:30,302] DESKTOP-SMGQBBM/INFO/locust.main: Starting Locust 0.8
[2017-10-30 22:17:30,302] DESKTOP-SMGQBBM/INFO/locust.runners: Hatching and swarming 10 clients at the rate 2 clients/s...
 Name # reqs # fails Avg Min Max | Median req/s

....


 [2017-10-30 22:18:30,301] DESKTOP-SMGQBBM/INFO/locust.main: Time limit reached. Stopping Locust.
 [2017-10-30 22:18:30,302] DESKTOP-SMGQBBM/INFO/locust.main: Shutting down (exit code 0), bye.
 Name # reqs # fails Avg Min Max | Median req/s
 --------------------------------------------------------------------------------------------------------------------------------------------
 GET / 117 0(0.00%) 31 17 96 | 28 2.10
 --------------------------------------------------------------------------------------------------------------------------------------------
 Total 117 0(0.00%) 2.10

 Percentage of the requests completed within given times
 Name # reqs 50% 66% 75% 80% 90% 95% 98% 99% 100%
 --------------------------------------------------------------------------------------------------------------------------------------------
 GET / 117 28 30 36 37 49 62 69 72 96
 --------------------------------------------------------------------------------------------------------------------------------------------
 Total 117 28 30 36 37 49 62 69 72 96

启动参数：

03. 安装环境：Windows

Mon, 16 Oct 2017 10:00:11 +0800

Windows 系统下安装 IntelliJ IDEA

更新记录

2016-12：IntelliJ IDEA 2016.3 版本出来之后，Windows 的安装过程增加了一个可以勾选选用 JetBrains 自己开发的一个 JRE 环境，这个建议 64 位系统的用户可以勾选上，按正常理论效果比 Oracle 应该会好。

系统要求

系统支持：Microsoft Windows 8 / 7 / Vista / 2003 / XP（每个系统版本的 32 位和 64 位都可以）

JDK 版本：Oracle JDK 1.6 或以上

内存：最低要求 1 GB，推荐 2 GB 以上

硬盘：最低要求 2 GB

显示器：最低要求 1024 X 768 分辨率

更多信息可以阅读：https://www.jetbrains.com/idea/download/system_requirements.jsp?os=win

首次安装

IntelliJ IDEA 的安装是非常简单的，不需要做过多的选择，可以说简单到都是 Next 即可。

04. 安装环境：Ubuntu

Mon, 16 Oct 2017 09:00:11 +0800

Ubuntu 系统下安装 IntelliJ IDEA

系统要求

系统支持：只要是支持 GNOME 或 KDE 桌面系统，建议是 Ubuntu（32位和64位都可以）

JDK 版本：Oracle JDK 1.6 或以上

内存：最低要求 1 GB，推荐 2 GB 以上

硬盘：最低要求 2 GB

显示器：最低要求 1024 X 768 分辨率

更多信息可以阅读：https://www.jetbrains.com/idea/download/system_requirements.jsp?os=linux

重要说明

我这里以 Ubuntu 系统为例进行讲解。但是，在学习下面内容之前请先看下章节：Windows 下安装

因为它们配置流程是基本一样的，只是系统不同，开始的步骤不太一样而已，因此相同部分我这里是不会再讲的，我只讲 IntelliJ IDEA 在 Linux 安装特殊的地方。

Ubuntu 下安装过程

先把你下载到的 ideaIU-14.1.4.tar.gz 移动到你平时存放软件的目录下，然后进行解压，我电脑是放在 /opt 下。

终端下解压命令：tar xfz ideaIU-14.1.4.tar.gz，解压出来的目录名称是：idea-IU-141.1532.4

可能在解压过程中你需要 sudo 命令权限，或者是切换到 root 账号下。如果你是切换到 root 用户下就一定要注意，解压完记得再切回来你常用的账户，不然等下生成的 IntelliJ IDEA 配置文件是放在 /home/root 下，这样就跟你常用的那个用户没啥关系了。

appium新手入门（4）—— java-client安装与测试

Thu, 07 Sep 2017 10:24:12 +0800

关联阅读：

appium新手入门（1）—— appium介绍

appium新手入门（2）—— 安装 Android SDK

appium新手入门（3）—— 安装 appium Server

#### 前提条件 ----

当你点击这一章时，说明你是打算使用 Java 语言编写 appium 自动化测试脚本的。

1、安装 Java 环境 ,我想这一步你已经搞定了

2、安装 IntelliJ IDEA , 当然，你喜欢用 Eclipse 也可以，不过，我仍然推荐 IDEA。

3、安装 Maven, Java开发必备啊！

Maven 安装 Java-client

首先，启动IntelliJ IDEA，创建Maven项目（参考selenium java教程），然后在maven配置文件中添加Java-client配置。

<dependency>
 <groupId>io.appium</groupId>
 <artifactId>java-client</artifactId>
 <version>5.0.0-BETA9</version>
 <scope>test</scope>
</dependency>

最新版本号可以到 github Java-client开源项目上查看。

#### 运行第一个Appium测试 ---- * __第一步__，启动Android模拟器。

（四）Git克隆与更新代码

Thu, 31 Aug 2017 02:00:11 +0800

请先阅读：

GitHub注册与Git安装

通过Git提交代码到GitHub

克隆项目

我们除了可以向GitHub上提交项目外，更多的时候是我们到上面克隆（下载）优秀的开源项目来用，当然也可以将使用过程中发现的bug，通过建立分支的方式提交给项目的原作者。我们现在的场景是在家将项目提交到了GitHub上，现在来到公司，需要将GitHub上的项目克隆到本地，那么对于公司的电脑来说，同样需要与GitHub建立连接。

首先，下载安装Git。

其次，通过Git生成本地公钥，并且将公钥添加到GitHub中。

最后，设置仓库人员的用户名和邮箱地址。

具体操作请参考前面的章节。当一切都设置完成后，就可以从GitHub上克隆项目到本地了。我们同样以Windows系统为例，打开Git Bash。

Company@MININT-IQVJFIT /d/my_test
$ git clone git@github.com:defnngj/project-name.git

Cloning into 'project-name'...
remote: Counting objects: 3, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 3 (delta 0), pack-reused 0
Receiving objects: 100% (3/3), done.
Checking connectivity... done.

Company@MININT-IQVJFIT /d/my_test
$ cd project-name/

Company@MININT-IQVJFIT /d/my_test/project-name (master)
$ ls

test_case.py

“git clone” 命令用于克隆GitHub上的项目到本地。通过“cd”命令进入项目目录，查看项目文件。

另外，我们也可以直接通过http链接克隆项目：

$ git clone https://github.com/defnngj/project-name

更新项目

这次更新我们项目做了较大的变更，创建文件的文件与文件夹，并且删除了原有文件。

4.Json简介

Sun, 27 Aug 2017 04:41:43 +0800

官方解释

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

什么是JSON

首先json是字符串。

大家都知道，字符串是用来传递信息的。json字符串实际上就是一种规定了格式的字符串，

通过这种格式，我们可以在不同的编程语言之间互相传递信息，比如我们可以把javascript的对象转换成json传递给java，这样java可以反解析出java语言自身代表的对象；同理，我们可以把java对象转成json，通过解析json，python语言可以把json转成是自身的dict或者是list，json统一了交流的格式，使得信息可以在不同的语言间顺畅传递。

JSON解析的简单例子

比如，我们可以把json字符串转成python语言的dict

#coding: utf-8
import json

json_str = """
{
 "id" : 90,
 "name" : "python",
 "url" : "http://www.v2ex.com/go/python",
 "title" : "Python",
 "title_alternative" : "Python",
 "topics" : 7646,
 "stars" : 4862,

 "header" : "这里讨论各种 Python 语言编程话题，也包括 Django，Tornado 等框架的讨论。这里是一个能够帮助你解决实际问题的地方。",


 "footer" : null,

 "created" : 1278683336,
 "avatar_mini" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_mini.png?m=1504080972",
 "avatar_normal" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_normal.png?m=1504080972",
 "avatar_large" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_large.png?m=1504080972"
}
"""
res = json.loads(json_str)

print(res['id']) # 90
print(res['name']) # python
print(res['url']) # http://www.v2ex.com/go/python

原始封面

JMeter官方文档：4. 创建web测试计划

Thu, 24 Aug 2017 12:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

4. 创建web测试计划

在这一章，我们将学习如何创建基本的测试计划来测试一个web网站。您将创建五个用户并发送请求到JMeter网站的两个页面。同时，设置用户运行测试两次。因此，请求的总数是（5个用户）x（2个请求）x（重复2次）＝20个HTTP请求。要构建测试计划，您将使用以下元素：线程组、HTTP请求、HTTP请求默认值和图表结果。

想要创建一个更深层次的测试计划，请查看建立一个更高级的web测试计划。

4.1 添加用户

做每一个测试计划之前的第一步是添加一个线程组。在JMeter的线程组中设置要模拟的用数量，请求发送的频率，以及请求发送的次数。

在添加线程组之前先鼠标选中测试计划，然后单击鼠标右键，选择 “ 添加 → 线程组 ”。

你现在应该看到在测试计划下的线程组元素。如果您没有看到元素，你需要单击“测试计划”来展开‘测试计划树’。

接下来，你需要修改默认的属性。在树中选中该线程组，如果你已经选择。你现在应该在JMeter窗口右部看到线程组控制面板（见下面的图4.1）

图4.1 线程组默认值

我们为线程组提供一个更具体的描述性名称，在名称栏里输入：JMeter Users。

接下来，设置用户数量（线程数量）为5.

在下一个字段中，设置过渡时期，保留默认值1，这个属性告诉Jmeter启动每个用户需要多长时间.例如，如果你设置过渡时期为5s，Jmeter将会在5s之内完成所有用户的启动，所以，如果你设置了5个线程数，过渡期为5s，那么启动线程之间的过渡期将是1s（5用户/5s=每秒1个用户）.如果你设置这个值为0，那么JMeter将立即开启你所有的线程，中间没有间隔。

最后一行，选择循环2次，这个属性是告诉JMeter要重复测试多少次，如果你设置的值是1，JMeter将就跑一遍，如果选择‘永远’复选框的话，JMetre将重复运行测试计划。

在大多数应用程序中，你必须手动保存才能生效，然而，在JMeter中，控制面板会在你进行更改时自动保存。如果你改变了一个元素的名称，那么在你离开控制面板上之后，新元素、就会生效（例如，当我们在选择其它树元素时）

查看图4.2已经设置好的JMeter线程组

4.2添加HTTP请求默认值

现在我们已经定义了我们的用户，是时候来定义他们将要执行的任务了。在本节中，您将指定你的HTTP请求的默认设置。然后，在第4.3节中，您将添加使用此处指定的默认设置的HTTP请求元素。

首先选择JMeter用户（线程组）。点击你的鼠标右键来添加菜单，然后选择 “添加→配置元件→HTTP请求默认值”。然后选中HTTP请求默认值以查看其控制面板（见图4.3）。

图4.3，HTTP请求默认值

appium简明教程（4）——appium client的安装

Thu, 17 Aug 2017 07:24:12 +0800

appium client是对webdriver原生api的一些扩展和封装。它可以帮助我们更容易的写出用例，写出更好懂的用例。

appium client是配合原生的webdriver来使用的，因此二者必须配合使用缺一不可。

从本节开始，教程的内容将涵盖3个语言，ruby/python/java。

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

安装appium client

ruby篇（一定要在线安装）

ruby的appium client叫做appium lib，为什么是这样就不解释了，总之是历史原因。

首先update rubygem和bundler(说老实话，真的不需要，但官方文档上这么写)

gem update --system ;\
gem update bundler

然后使用gem安装

gem uninstall -aIx appium_lib ;\(这个也不是必须的)
gem install --no-rdoc --no-ri appium_lib

python篇（尽量在线安装）

推荐使用pip安装

pip install Appium-Python-Client

当然了也可以在Pipy上下载源码安装

tar -xvf Appium-Python-Client-X.X.tar.gz（windows上用7zip可以解压）
cd Appium-Python-Client-X.X
python setup.py install

最后，也可以通过github安装（要git客户端）

git clone git@github.com:appium/python-client.git
cd python-client
python setup.py install

java篇（在线安装）

java的话用maven安装就可以了

<dependency>
 <groupId>io.appium</groupId>
 <artifactId>java-client</artifactId>
 <version>1.3.0</version>
</dependency>

当然了，也可以自己下载jar包，请自行选择最新版本。

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

原始封面

性能测试基础（四）吞吐量

Fri, 11 Aug 2017 12:59:11 +0800

我们每天的生活中都在用水用电，如果我们把水龙头拧到最大，还是一滴水不出。那我们就会找物业/房东去询问情况，但一般不会想过去找自来水公司解决。我们每天都会上网，看电影很卡，需要等很久才缓冲一个几帧；打开网页很慢，IE状态条一直50%，那我们就会找电信服务器商，而不是某视频网站的客服。

以上的情况是正常的，这是生活常识。我想说明的是，你可能从来不关心一个自来水厂供应多少水，但供应多少水对一个自来厂来说却非常重要。你也可能从来不关心一个系统的吞吐量，但吞吐量对一个系统来说却非常重要。

吞吐量

指在一次性能测试过程中网络上传输的数据量的总和。

对于交互式应用来说，吞吐量指标反映的是服务器承受的压力，在容量规划的测试中，吞吐量是一个重点关注的指标，因为它能够说明系统级别的负载能力，另外，在性能调优过程中，吞吐量指标也有重要的价值。如一个大型工厂，他们的生产效率与生产速度很快，一天生产10W吨的货物，结果工厂的运输能力不行，就两辆小型三轮车一天拉2吨的货物，比喻有些夸张，但我想说明的是这个运输能力是整个系统的瓶颈。

但是，用吞吐量来衡量一个系统的输出能力是极其不准确的，用个最简单的例子说明，一个水龙头开24小时，流出10吨水；10个水龙头开1秒钟，流出0.1吨水。当然是一个水龙头的吞吐量大。你能说1个水龙头的出水能力远超10个水龙头？所以，我们要加单位时间的限制，每秒/出水量，这就引出了一个新的概念–吞吐率。

吞吐率

单位时间内网络上传输的数据量，也可以指单位时间内处理客户请求数量。它是衡量网络性能的重要指标，通常情况下，吞吐率用“字节数/秒”来衡量，当然，你可以用“请求数/秒”和“页面数/秒”来衡量。其实，不管是一个请求还是一个页面，它的本质都是在网络上传输的数据，那么来表示数据的单位就是字节数。

但是从业务的角度看，吞吐率也可以用“业务数/小时”、“访问人数/小时”、“页面访问量/小时”来衡量。例如，在银行卡审批系统中，可以用“千件/小时”来衡量系统的业务处理能力。那么，从用户的角度，一个表单提交可以得到一次审批。这又引出来一个概念—事务。

事务

就是用户某一步或几步操作的集合。不过，我们要保证它有一个完整意义。比如用户对某一个页面的一次请求，对某系统的一次登录，对商品的一次确认支付过程。这些我们都可以看作一个事务。那么如何衡量服务器对事务的处理能力。又引出一个概念—-TPS

TPS (Transaction Per second)

每秒钟系统能够处理事务或交易的数量，它是衡量系统处理能力的重要指标。

点击率（Hit Per Second）

点击率可以看做是TPS的一种特定情况。点击率更能体现用户端对服务器的压力。TPS更能体现服务器对客户请求的处理能力。

每秒钟用户向Web服务器提交的HTTP请求数。这个指标是Web 应用特有的一个指标；Web应用是“请求—响应”模式，用户发一个申请，服务器就要处理一次，所以点击是Web应用能够处理的交易的最小单位。如果把每次点击定义为一个交易，点击率和TPS就是一个概念。容易看出，点击率越大。对服务器的压力也越大，点击率只是一个性能参考指标，重要的是分析点击时产生的影响。

需要注意的是，这里的点击不能简单的看作鼠标的一次“单击”操作，也许一次“单击”操作中，客户端可能向服务器发现多个HTTP请求。

__吞吐量指标的作用：__

再次将话题回归到吞吐量上，在我们的性能测试中查看吞吐量对我们的测试有什么意义呢。

1. 用于协助设计性能测试场景，以及衡量性能测试场景是否达到了预期的设计目标：在设计性能测试场景时，吞吐量可被用于协助设计性能测试场景，根据估算的吞吐量数据，可以对应到测试场景的事务发生频率，事务发生次数等；另外，在测试完成后，根据实际的吞吐量可以衡量测试是否达到了预期的目标。

2. 用于协助分析性能瓶颈：吞吐量的限制是性能瓶颈的一种重要表现形式，因此，有针对性地对吞吐量设计测试，可以协助尽快定位到性能瓶颈的所在位置。

__扩展：__

RBI（rapid bottleneck identify）

是Empirix公司提出的快速识别系统性能瓶颈的方法。该方法基于以下事实。

1. 发现的80%系统的性能瓶颈都由吞吐量制约；

2. 并发用户数和吞吐量瓶颈之间存在一定的关联；

3. 采用吞吐量测试可以更快速定位问题。

通过不断增加并发用户数和吞吐量观察系统的性能瓶颈。然后，从网络、数据库、应用服务器和代码本身4个环节确定系统的的性能瓶颈。

原始封面

（四）通过id去定位页面上的元素

Thu, 10 Aug 2017 07:27:57 +0800

关于定位

UI的自动化测试的主要操作就是找到页面上的元素并且操作元素。找到元素一般有2个目的

操作元素: 比如点击，输入内容之类的
获取这个元素的某些属性: 比如获取一个段落元素(p)的内容，通过这个内容去验证测试是否达到了预期的效果(断言)

定位方式

selenium的javascript binding支持下面一些定位方法

By.className( name )
By.css( selector )
By.id( id )
By.js( script, …var_args )
By.linkText( text )
By.name( name )
By.partialLinkText( text )
By.xpath( xpath )

在这些定位方式里，最简单最常用的定位方式就是通过元素的id进行定位

目的

熟悉selenium webdriver 定位方式
学会通过id属性去定位元素
学会使用sendKeys()方法

练习对象

我们使用html5-test-page作为我们的练习对象。

将html代码拷贝一份并保存到本地，文件名为index.html。

场景

我们将使用id定位下图所示的输入框，并输入一些内容

代码

新建文件by_id.js，并键入下面的内容。

var path = require('path');
var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var testFile = "file://" + path.join(__dirname, "index.html")

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get(testFile)

dr.findElement(By.id('input__text')).sendKeys('测试教程网');
dr.findElement(By.id('input__password')).sendKeys('password');
dr.findElement(By.id('input__webaddress')).sendKeys('http://www.itest.info');
dr.findElement(By.id('input__emailaddress')).sendKeys('service@itest.info');
dr.findElement(By.id('input__phone')).sendKeys('13888888888');
dr.findElement(By.id('input__search')).sendKeys('keywords');
dr.findElement(By.id('input__text2')).sendKeys('6666666');
dr.findElement(By.id('input__text3')).sendKeys('should be error');
dr.findElement(By.id('input__text4')).sendKeys('should be valid');

运行结果

如下图所示

python测试笔试题1

Wed, 26 Jul 2017 09:30:25 +0800

哪一个方法用来返回变量类型？

which function is usd to get type of a variable

答案 type

哪一个方法用来列出一个类下的所有属性，方法，以及变量？

which function is used to list all names of a class’s attributes?

答案 dir

字符串方法format是用来去掉字符串的左右空格的么？

is the methods format used to get rid of blank space around a string?

答案不是

python 的类可以有多个父类么？

can a class inheritance from multiple classes?

答案是

哪一个函数是用来获得字符串长度？

which function is used to get the length of a string? len

答案：len

（四）一个bug的生命周期

Tue, 25 Jul 2017 12:59:11 +0800

又一篇测试技术普及文章，希望你在被各种技术吸引的同时，能时常来整理和总结软件测试最基本的知识。
#### Bug的属性 ---- __Bug重现环境__

这个应该是我们重现bug的一个前提，如果没有这个前提，我们可能会无法重现问题，或者跟本就无从下手。

操作系统

浏览器

其它（这个“其它”非常重要）

问题类型

根据JIRA的管理系统的划分，bug 只是问题的一种，它可以用于跟踪多种不同类型的问题（其实，他只是将bug做为一子类而已）。

JIRA系统缺省提供的问题类型（大部分的系统都可以自定义类型的，这样就增加了灵活性。）

Bug : 测试过程、维护过程发现影响系统运行的缺陷。（这就是一般测试人员所提交的bug）
New Feature : 对系统提出的新功能。（单个的小需求可以，如果大的话，就相当于一个需求，放到这里是不合理的。）
Task : 需要完成的一任务。（开发或测试任务指派。）
Improvement : 对现有系统功能的改进。（一般产品经理或产品体验师做的事）

Bug 类型

下面看一些常见的分类：

划分方式一：

　　* 代码错误

　　* 设计缺陷

　　* 界面优化

　　* 配置相关

　　* 安装部署

 * 性能问题

　　* 标准规范

　　* 测试代码

　　* 其它

划分方式二：

　　* 功能类（function）

　　* 性能类（performance）

　　* 界面类（UI）

　　* 易用性类（usability）

　　* 兼容性类（compatibility）

　　* 其它（else）

（四）selenium3 浏览器驱动

Tue, 04 Jul 2017 12:59:11 +0800

### 下载浏览器驱动

当selenium升级到3.0之后，对不同的浏览器驱动进行了规范。如果想使用selenium驱动不同的浏览器，必须单独下载并设置不同的浏览器驱动。

各浏览器下载地址：

Firefox浏览器驱动：geckodriver

Chrome浏览器驱动：chromedriver taobao备用地址

IE浏览器驱动：IEDriverServer

Edge浏览器驱动：MicrosoftWebDriver

Opera浏览器驱动：operadriver

PhantomJS浏览器驱动：phantomjs

注：部分浏览器驱动地址需要科学上网。

### 设置浏览器驱动

我的电脑–>属性–>系统设置–>高级–>环境变量–>系统变量–>Path，将“C:\driver”目录添加到Path的值中。

Path
;C:\driver

### 设置浏览器驱动

验证不同的浏览器驱动是否正常使用。

import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.edge.EdgeDriver;
import org.openqa.selenium.ie.InternetExplorerDriver;
import org.openqa.selenium.opera.OperaDriver;
import org.openqa.selenium.phantomjs.PhantomJSDriver;

……

WebDriver driver = new ChromeDriver(); //Chrome浏览器

WebDriver driver = new FirefoxDriver(); //Firefox浏览器

WebDriver driver = new EdgeDriver(); //Edge浏览器

WebDriver driver = new InternetExplorerDriver(); // Internet Explorer浏览器

WebDriver driver = new OperaDriver(); //Opera浏览器

WebDriver driver = new PhantomJSDriver(); //PhantomJS

……

原始封面

（四）控制浏览器操作

Tue, 27 Jun 2017 07:37:11 +0800

### 控制浏览器窗口大小

有时候我们希望能以某种浏览器尺寸打开，让访问的页面在这种尺寸下运行。例如可以将浏览器设置成移动端大小(480* 800)，然后访问移动站点，对其样式进行评估；WebDriver提供了set_window_size()方法来设置浏览器的大小。

from selenium import webdriver

driver = webdriver.Firefox()
driver.get("http://m.baidu.com")

# 参数数字为像素点
print("设置浏览器宽480、高800显示")
driver.set_window_size(480, 800)
driver.quit()

在PC端执行自动化测试脚本大多的情况下是希望浏览器在全屏幕模式下执行，那么可以使用maximize_window()方法使打开的浏览器全屏显示，其用法与set_window_size() 相同，但它不需要参数。

### 控制浏览器后退、前进

在使用浏览器浏览网页时，浏览器提供了后退和前进按钮，可以方便地在浏览过的网页之间切换，WebDriver也提供了对应的back()和forward()方法来模拟后退和前进按钮。下面通过例子来演示这两个方法的使用。

from selenium import webdriver

driver = webdriver.Firefox()

#访问百度首页
first_url= 'http://www.baidu.com'
print("now access %s" %(first_url))
driver.get(first_url)

#访问新闻页面
second_url='http://news.baidu.com'
print("now access %s" %(second_url))
driver.get(second_url)

#返回（后退）到百度首页
print("back to %s "%(first_url))
driver.back()

#前进到新闻页
print("forward to %s"%(second_url))
driver.forward()

driver.quit()

为了看清脚本的执行过程，下面每操作一步都通过print()来打印当前的URL地址。

### 刷新页面

有时候需要手动刷新（F5）页面。

……
driver.refresh() #刷新当前页面
……

原始封面

浅谈测试用例

Tue, 17 Jun 2025 17:29:15 +0800

#### 一、什么是测试用例？ ---- 测试用例是为某个特殊目标而编制的一组测试输入、执行条件以及预期结果，以便测试某个程序路径或核实是否满足某个特定需求。

通俗的讲：就是把我们测试系统的操作步骤用按照一定的格式用文字描述出来。

#### 二、写测试用例有什么好处？ ---- * 理清思路，避免遗漏

这里是我们认为最重要的一点，假如我们测试的项目大而复杂，我们可以把项目功能细分，根据每一个功能通过编写用例的方式来整理我们测试系统的思路，避免遗漏掉要测试的功能点。

跟踪测试进展

通过编写测试用例，执行测试用例，我们可以很清楚的知道我们的测试进度。

历史参考

在我们所做的项目中，也许会有很多功能是相同或相近的，我们对这类功能设计了测试用例，便于以后我们遇到类似功能的时候可以做参考依据。

重复性

我们测试一个系统不是一个人测一遍就算测完的，需要多人反复的进行测试，那么我们就需要测试用例来规范和指导我们的测试行为。

#### 三、测试用例的方法 ---- 好吧，咱知道啥是测试用例了，也是知道为什么要写测试用例了，那到底应该怎么写？无从下手啊。我们在写测试用例之前，先学习几种方法，它是我们写测试用例的指导思想。

等价类划分

等价类是指某个输入域的一个特定的子集合，在该子集合中各个输入数据对于揭露程序中的错误都是等效的，也就是说，如果用这个等价类中的代表值作为测试用例未发现程序错误，那么该类中其他数据（测试用例）也不会发现程序中的错误。

有效等价类： 输入满足程序输入的要求（来自规格说明书），通俗的说就是正确的输入。

无效等价类： 输入不满足程序输入的要求，即异常输入，需要系统对此有一定的容错性。

例如：

一个输入框要求输入1-10000的数字

有效等价类：可以输入1-10000之间的数来验证，如：2、5、99、8495……

无效等价类：可以输入1-10000之外的任意字符验证，如：0、10001、字母、下划线、特殊符号、空格、回车…..

边界值

边界值是对等价类的补充，测试工作经验告诉我们，大量的错误是出在输入输出的边界价上。我们还拿上面的例子，一个输入框要求输入1-10000之间的数。我们要测它有没有超出这个范围，如：0、-1、-2、1000、10001…..等等，来判定是否超出了我们的范围。

因果图

因果图方法最终生成的就是判定表，它适合于检查程序输入条件的各种组合情况。举个例子：原因：A=0，B=0，结果我就可以判定：A=B。确切的说他是一种因果关系思想。它会无形中指导这我们的测试。当然了，我们为了以免遗漏，可以把系统中的因果关系用图画出。不过系统大而复杂的话就是个体力活了。呵呵。

错误推测法

基于经验和直觉推测出系统可能存在的错误，从而有针对性的设计测试用例的方法。

其它

设计测试用例的方法有很多，我们常用就上面几种，其它的方法还有：状态迁移图、流程分析法、正交验证法等等。

#### 四、测试用例的格式与要素 ---- 一个测试用例应该包括：编号，标题，测试场景，测试步骤，预期结果。

当然还可加入一些它选项，如：优先级、测试阶段….

编号：

标题:

测试环境：

测试步骤：

预期结果：

关于测试用例的存放管理：

1、项目管理系统自带的用例管理，一般用例会与项目挂钩，有固定的格式，搜索、修改等功能，使用起来非常方便。如：禅道项目管理、QC、bugfree 等等都带的有用例管理功能。

2、通过world\Excel文档形式管理，这样的好处就是自己定义测试用例的格式。

面来看一个具体的测试用例。我们会有更深刻的认识。

编号：001

标题: 系统登录测试用例

测试环境：
Windows 10/Chrome 58


测试步骤：
1、打开浏览器，输入系统网站，打开登录页面。
2、用户名密码为空，点击登录按钮
3、输入用户名，密码为空，点击登录按钮。
4、用户名为空，输入密码，点击登录按钮。
5、用户名正确，密码错误，点击登录按钮。
....


预期结果：
1、成功打开首页。
2、系统提示：用户名密码不能为空。
3、系统提示：密码不能为空。
4、系统提示：用户名不能为空。
5、系统提示：用户名或密码错误。
....

__最后__ ，写好测试用例，除了掌握基本的测试方法之外，最重要的是，要去深入理解业务需求。从需求文档中抽出测试点；另外善于总结以往测试中发现的bug，完善测试用例。

原始封面

wrk系列教程(5)lua扩展

Sun, 03 Mar 2019 02:00:11 +0800

官方文档上面对wrk的lua脚本扩展方式有详细的说明。

lua脚本可以为wrk增加更多灵活的功能，通过代码扩展，wrk的定制能力会有很大的提升。

钩子函数

wrk提供了一些简单的钩子函数，可以实现在测试过程中对请求及场景做定制化的增强。

这些函数分别是

setup()

原始封面

python简明教程: 5. 类

Sun, 18 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者


####################################################
# 5. 类
####################################################

# 以继承object的方式来定义1个类
class Human(object):
 # 类属性，所有类实例都共享
 species = "H. sapiens"

 # 基本的构造函数，当类实例化的时候会自动被调用
 # 注意双下划线开头和结尾的变量是python保留的
 # 你不应该自己定义类似风格的变量
 def __init__(self, name):
 # 将参数里name赋值给同名的实例属性
 self.name = name

 # 初始化属性
 self.age = 0

 # 实例方法，第一个参数必须是self
 def say(self, msg):
 return "{0}: {1}".format(self.name, msg)

 # 类方法，所有实例共享
 # 调用的时候第1个参数代表这个类本身
 @classmethod
 def get_species(cls):
 return cls.species

 # 静态方法被调用的时候是不需要传入类或实例的引用(kls,self)的
 @staticmethod
 def grunt():
 return "*grunt*"

 # 属性有点像getter.
 # 这个将 age() 方法变成了同名的只读的属性(调用的时候不用加括号了)
 @property
 def age(self):
 return self._age

 # 这样就可以允许属性被赋值了
 @age.setter
 def age(self, age):
 self._age = age

 # 这样就可以允许属性被删除
 @age.deleter
 def age(self):
 del self._age


# 实例化1个类
i = Human(name="Ian")
print i.say("hi") # 打印出 "Ian: hi"

j = Human("Joel")
print j.say("hello") # 打印出 "Joel: hello"

# 调用类方法
i.get_species() # => "H. sapiens"

# 修改类属性
Human.species = "H. neanderthalensis"
i.get_species() # => "H. neanderthalensis"
j.get_species() # => "H. neanderthalensis"

# 调用静态方法
Human.grunt() # => "*grunt*"

# 更新属性
i.age = 42

# 获取属性
i.age # => 42

# 删除属性
del i.age
i.age # => 抛出AttributeError异常

原始封面

（五）Docker 仓库

Mon, 22 Jan 2018 14:40:11 +0800

前面在下载镜像的适应已经用到了Docker仓库，如果是镜像的一个托管平吧。

仓库

一个容易混淆的概念是注册服务器（Registry）。实际上注册服务器是管理仓库的具体服务器，每个服务器上可以有多个仓库，而每个仓库下面有多个镜像。从这方面来说，仓库可以被认为是一个具体的项目或目录。例如对于仓库地址 registry.hub.docker.com/ubuntu 来说，registry.hub.docker.com是注册服务器地址，ubuntu是仓库名。大部分时候，并不需要严格区分这两者的概念。

Docker Hub

目前Docker官方维护了一个公共仓库 Docker Hub：https://hub.docker.com

我们可以在Docker Hub上完成注册。这样就可以使用Docker Hub 来托管我们的镜像了。

通过docker search命令来查找官方仓库中的镜像，并利用docker pull 命令来将它下载到本地。

$ sudo docker search ubuntu

使用国内镜像

参考地址：https://www.docker-cn.com/registry-mirror

临时性的使用：

$ sudo docker pull registry.docker-cn.com/library/ubuntu:16.04

永久性的使用：

修改 /etc/docker/daemon.json文件（没有的话可以手动创建，需要通过root用户操作）并添加上 registry-mirrors 键值。

{
 "registry-mirrors": ["https://registry.docker-cn.com"]
}

修改保存后重启Docker服务以使配置生效。

$ sudo service docker restart

原始封面

（五）Java数据结构：数组和HashMap

Wed, 17 Jan 2018 14:38:11 +0800

Java的数据结构包含的数接口和类分好多种，不过，我觉得最常用的就是数组和HashMap（反正是我最常用的），所以，将他们拿出来介绍一下。

数组

数组保存的是一组有顺序的、具有相同类型的数据。在Java的数组中，所有数据元素的数据类型都是相同的，可以通过数组的下标来访问数组。


public class JavaList {

 public static void main(String[] args) {

 String[] group = new String[5];
 group[0] = "小明";
 group[1] = "老师";
 group[2] = "老王";
 group[3] = "张三";
 group[4] = "李四";

 for (int i = 0; i < group.length; i++) {
 System.out.println(group[i]);
 }
 }
}

在创建数组的时候需要为其分配空间大小，在本例子中，通过循环将 0~4 之间的 5 个数放到的数组 group 中。

TDD实战（五）“井字游戏” 需求三

Mon, 08 Jan 2018 12:45:11 +0800

需求3

继续实现需求3，检查所可能获胜的情况，只要满足其中一个，就宣布相应玩家获胜。

最先在水平、锤直或对角线上将自己的3个标记连起来的玩家获胜。

测试用例1

现在我们检查是否有垂直线完全被某个玩家占据。

@Test
public void whenPlayAndWholeVerticalLineThenWinner(){
 ticTacToe.play(2,1); //X
 ticTacToe.play(1,1); //O
 ticTacToe.play(3,1); //X
 ticTacToe.play(1,2); //O
 ticTacToe.play(2,2); //O
 String actual = ticTacToe.play(1,3); //O
 assertEquals("O is the winner", actual);
}

一个玩家的棋子占据整条垂直线就赢了。

实现代码1

这个实现和前面一个类似，前面在水平方向上做检查，现在需要在垂直方向上做同样的检查。

private boolean isWin(){
 int playerTotal = lastPlayer * 3;

 for(int i = 0; i < SIZE; i++){
 if(board[0][i] + board[1][i] + board[2][i] == playerTotal){
 return true;
 }else if(board[i][0] + board[i][1] + board[i][2] == playerTotal){
 return true;
 }
 }
 return false;
}

** 执行测试用例1 检查它是否运行通过。

Android测试（五）：Instrumented 单元测试

Wed, 20 Dec 2017 14:35:12 +0800

原文：https://developer.android.com/training/testing/unit-testing/instrumented-unit-tests.html

Instrumented 单元测试是在真机和模拟器上运行的测试，它可以利用Android框架API和支持的API（如Android测试支持库）。如果你的测试需要访问工具信息（例如目标应用程序的Context），或者需要真正实现Android框架组件（如Parcelable或SharedPreferences对象），则应该创建Instrumented 单元测试。

使用Instrumented单元测试还有助于减少编写和维护mock代码所需的工作量。如果你愿意，仍然可以自由地使用一个mock框架模拟任何依赖关系。

设置测试环境

在你的Android Studio项目中，你必须将mock测试的源文件存储在module-name/src/androidTest/java/ 中。创建新项目时该目录已经存在，并包含示例代码。

在开始之前，你应该下载Android测试支持库安装程序，该安装程序提供的API可让你快速构建和运行应用程序的检测代码。测试支持库包括用于功能性UI测试（Espresso和UI Automator）的JUnit 4测试运行器（AndroidJUnitRunner）和API。

还需要为项目配置Android测试依赖项，以使用测试运行程序和测试支持库提供的规则API。为了简化测试开发，还应该包含Hamcrest库，它可以让你使用Hamcrest匹配器API创建更灵活的断言。

在你的App的顶级build.gradle文件中将这些库指定为依赖项：

dependencies {
    androidTestCompile 'com.android.support:support-annotations:24.0.0'
    androidTestCompile 'com.android.support.test:runner:0.5'
    androidTestCompile 'com.android.support.test:rules:0.5'
    // Optional -- Hamcrest library
    androidTestCompile 'org.hamcrest:hamcrest-library:1.3'
    // Optional -- UI testing with Espresso
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
    // Optional -- UI testing with UI Automator
    androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.2'
}

警告： 如果构建配置包含support-annotations库的编译依赖项和espresso-core库的androidTestCompile依赖项，则由于依赖冲突，构建可能会失败。请按照下面步骤更新对espresso-core的依赖关系：

androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
    exclude group: 'com.android.support', module: 'support-annotations'
})

要使用JUnit 4测试类，请确保将AndroidJUnitRunner指定为项目中的默认测试工具运行器，方法是在应用程序的模块级build.gradle文件中包含以下设置：

Fiddler（五）设置显式IP地址

Tue, 19 Dec 2017 13:45:11 +0800

在测试过程中，我们经常需要通过host在不同的环境之间切换，如果知道自己的环境是否切换成功，那么通过IP地址就很容易判断。

Fiddler设置显示IP地址

打开Fiddler, 菜单栏：Rules->Customize Rules… 或快捷键 Ctrl+R 。

通过快捷键 Ctrl+F ,搜索：static function Main() 函数。在函数中添加一行代码，如下：

 // The Main() function runs everytime your FiddlerScript compiles
 static function Main() {
 var today: Date = new Date();
 FiddlerObject.StatusText = " CustomRules.js was loaded at: " + today;
 // 显示IP 地址
 FiddlerObject.UI.lvSessions.AddBoundColumn("ServerIP", 120, "X-HostIP");

 // Uncomment to add a "Server" column containing the response "Server" header, if present
 // UI.lvSessions.AddBoundColumn("Server", 50, "@response.server");

 // Uncomment to add a global hotkey (Win+G) that invokes the ExecAction method below...
 // UI.RegisterCustomHotkey(HotkeyModifiers.Windows, Keys.G, "screenshot");
 }

然后，点击菜单栏：File –> Save 或快捷键 Ctrl+S，关闭窗口。

图片爬虫

Thu, 14 Dec 2017 02:52:34 +0800

图片爬虫

之前的例子里我们开发的都是文本爬虫，有时候我们需要去下载其他网站的图片并保存下来，这时候就需要用图片爬虫。

图片爬虫的套路其实跟文本爬虫差不多，最大的区别就是图片爬虫会去下载需要的文件，而文本爬虫可能会做其他的一些持久化的工作。

在这一节里，我们将实现下载煎蛋画廊第一页所有图片的功能。

具体步骤

访问煎蛋画廊主页，获取html文本
分析html文本，找出所有图片的html特征
解析html代码，拿到所有图片的src
通过src去下载图片

分析html代码

图片的html标签是img，所以我们只需要拿到页面上所有的img标签的src就好了。

下载文件

通过下面的代码，我们可以使用requests库来下载文件。

def download_file(url):
 print('Downding %s' %url)
 local_filename = url.split('/')[-1]
 r = requests.get(url, stream=True)
 with open(local_filename, 'wb') as f:
 for chunk in r.iter_content(chunk_size=1024):
 if chunk:
 f.write(chunk)
 f.flush()
 return local_filename

download_file方法只需要传入具体文件的地址就可以完成下载文件的功能了。

user agent

由于煎蛋做了非常简单的反爬虫处理，该站点会拒绝所有看起来像是爬虫的请求，大概的逻辑可能是如果后台发现请求的user agent异常，就返回403错误。

这里是User-Agent的基础知识，大家可以自行学习。

我们可以通过requests非常方便的修改请求的user agent，从而让被访问站点的后台没有办法识别出这次请求是否异常，达到绕过反爬机制的目的。

headers = {
 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
}

requests.get(url, headers=headers).text

上面代码的核心思想就是通过修改http headers中user agent，达到将请求伪装成是来自普通chrome浏览器访问的目的。

代码

新建名为get_images.py的文件，输入下面的内容


import requests
from bs4 import BeautifulSoup

headers = {
 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'
}

def download_file(url):
 print('Downding %s' %url)
 local_filename = url.split('/')[-1]
 r = requests.get(url, stream=True, headers=headers)
 with open(local_filename, 'wb') as f:
 for chunk in r.iter_content(chunk_size=1024):
 if chunk:
 f.write(chunk)
 f.flush()
 return local_filename

url = 'http://jandan.net/drawings'
soup = BeautifulSoup(requests.get(url, headers=headers).text, 'html.parser')

def valid_img(src):
 return src.endswith('jpg') and 'img.jandan.net' in src

for img in soup.find_all('img', src=valid_img):
 src = img['src']
 if not src.startswith('http'):
 src = 'http:' + src
 download_file(src)

运行

在命令行中输入

（五）验证函数调用次数和顺序

Sat, 25 Nov 2017 12:45:11 +0800

验证函数调用次数

例子：

import java.util.LinkedList;
import static org.mockito.Mockito.*;


public class MockitoDemo {

 @Test
 public void verifying_number_of_invocations(){
 LinkedList mockedList = mock(LinkedList.class);
 //using mock
 mockedList.add("once");

 mockedList.add("twice");
 mockedList.add("twice");

 mockedList.add("three times");
 mockedList.add("three times");
 mockedList.add("three times");

 //following two verifications work exactly the same - times(1) is used by default
 // 下面的两个验证函数效果一样,因为verify默认验证的就是times(1)
 verify(mockedList).add("once");
 verify(mockedList, times(1)).add("once");

 //exact number of invocations verification
 // 验证具体的执行次数
 verify(mockedList, times(2)).add("twice");
 verify(mockedList, times(3)).add("three times");

 //verification using never(). never() is an alias to times(0)
 // 使用never()进行验证,never相当于times(0)
 verify(mockedList, never()).add("never happened");

 //verification using atLeast()/atMost()
 // 使用atLeast()/atMost()
 verify(mockedList, atLeastOnce()).add("three times");
 verify(mockedList, atLeast(2)).add("five times");
 verify(mockedList, atMost(5)).add("three times");
 }
}

verify函数默认验证的是执行了times(1)，也就是某个测试函数是否执行了1次.因此，times(1)通常被省略了。

（五）测试级别设置

Sat, 25 Nov 2017 12:40:11 +0800

在我们创建测试用例时，大概分三个层级。

测试包（目录）
测试类（文件）
测试用例（@Test 注解的方法）

接下来介绍，如何控制这三个级别用例的执行。当然，核心还是通过 testng.mxl 文件配置。

指定运行测试包

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="测试套件" verbose="1" >
 <test name="简单测试">
 <packages>
 <package name="test.sample" />
 <package name="test.sample2" />
 </packages>
 </test>
</suite>

<packages>...</packages> 定义一组测试包。
<package.../> 定义一个测试包。
- name 指定测试包（目录）的名称。

指定运行测试类

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="测试套件" verbose="1" >
 <test name="简单测试">
 <classes>
 <class name="test.sample.FirstTest"/>
 <class name="test.sample.SecondTest"/>
 </classes>
 </test>
</suite>

指定测试类的运行，上一节已经介绍。

指定运行测试用例

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="测试套件" verbose="1" >
 <test name="简单测试">
 <classes>
 <class name="test.sample.FirstTest">
 <methods>
 <include name="testCase" />
 </methods>
 </class>
 </classes>
 </test>
</suite>

<methods>...</methods> 定义一组测试方法。
<include.../> 指定包含的测试用例（方法）。
- name 指定测试用例（方法）的名称。

注意： 测试方法<methods>必须包含在<class>标签中。

（五） IntelliJ-IDEA 创建 Maven 项目

Sat, 25 Nov 2017 12:35:11 +0800

IntelliJ IDEA 默认集成的就有 Maven 插件，所以，我们也可以直接使用它来创建 Maven 项目。

修改 Maven 配置

首先，打开 IntelliJ IDEA 开发工具，菜单栏： “File” —>“Settings…” ，搜索“Maven” 选项，如下图。

设置参数：

Maven home directory：设置本地安装的 Maven 目录。如“D:/java/apache-maven-3.5.0”。
User settings file：选择 Maven 目录下的配置文件。如“D:\java\apache-maven-3.5.0\conf\settings.xml” ，需要勾选“Override” 选项才能设置。
Locla repository：设置本地仓库地址。上一个选项设置好后，该选项自动设置。

注：这里也可以不用设置，直接使用 IntelliJ IDEA 的默认配置。

创建 Maven 项目

接下来在 IntelliJ IDEA 中创建 Maven 项目。菜单栏： “File” —>“New” —>“Project…” ，打开创建 Maven 。

requests如何自定义请求的headers?

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

有时候我们需要自定义一些请求的headers，比如我们可能需要将jwt的token放到headers里以完成鉴权。

>>> url = 'https://api.github.com/some/endpoint'
>>> headers = {'user-agent': 'my-app/0.0.1'}

>>> r = requests.get(url, headers=headers)

原始封面

（五）JUnit 注解之Fixture

Mon, 13 Nov 2017 12:40:11 +0800

继续介绍 JUnit 的注解。

什么是Fixture

Test Fixture 是指一个测试运行所需的固定环境，准确的定义：

The test fixture is everything we need to have in place to exercise the SUT

JUnit 中的 Fixture

被测试类同样使用上一小节的 Count , 创建 TestFixture 测试类。

import static org.junit.Assert.*;
import org.junit.*;

public class TestFixture {

 //在当前测试类开始时运行。
 @BeforeClass
 public static void beforeClass(){
 System.out.println("-------------------beforeClass");
 }

 //在当前测试类结束时运行。
 @AfterClass
 public static void afterClass(){
 System.out.println("-------------------afterClass");
 }

 //每个测试方法运行之前运行
 @Before
 public void before(){
 System.out.println("=====before");
 }

 //每个测试方法运行之后运行
 @After
 public void after(){
 System.out.println("=====after");
 }

 @Test
 public void testAdd1() {
 int result=new Count().add(5,3);
 assertEquals(8,result);
 System.out.println("test Run testadd1");
 }

 @Test
 public void testAdd2() {
 int result=new Count().add(15,13);
 assertEquals(28,result);
 System.out.println("test Run testadd2");
 }

}

代码中的注释已经对 @BeforeClass、 @AfterClass 、 @Before 、 @After 做了说明。

5. 实例: 找出所有是弱密码的用户

Mon, 06 Nov 2017 06:23:31 +0800

背景

当我们的测试数据是下面这些的时候，我们的用例是有问题的。

[
 {"name":"jack","password":"Iloverose"},
 {"name":"rose","password":"Ilovejack"},
 {"name":"tom","password":"password123"},
 {"name":"jerry","password":"password"}
]

我们的用例只能找出tom是弱密码的用户，jerry这个用户会成为漏网之鱼。

为什么

这是因为在unittest中，一旦某个测试方法中的断言失败，后续的断言都不会被执行。

还原一下上面的例子，当用例在断言tom失败后，for循环就退出了，测试方法也执行完毕了，后面jerry这条数据就不会被断言。

怎么办

我们可以重构一下我们的用例，让整个用例只断言1次，断言失败以后就把弱密码的用户打印出来。

代码

修改user_data.json文件，加入一些测试数据，修改后的user_data.json文件应该是

[
 {"name":"jack","password":"Iloverose"},
 {"name":"rose","password":"Ilovejack"},
 {"name":"tom","password":"password123"},
 {"name":"jerry","password":"password"},
 {"name":"fred","password":"123456"},
 {"name":"elma","password":"654321"}
]

新建test_password_4.py文件，内容如下


import unittest
import json

class WeakPasswordTeseCase1(unittest.TestCase):

 @classmethod
 def setUpClass(kls):
 data_file_path = './user_data.json'
 print('before all test methods')
 with open(data_file_path) as f:
 kls.test_data = json.loads(f.read())

 def test_week_password(self):
 res = True
 msg = []
 for data in self.test_data:
 passwd = data['password']
 tmp_res = True

 tmp_res = tmp_res and (len(passwd) >= 6)
 tmp_res = tmp_res and (passwd != 'password')
 tmp_res = tmp_res and (passwd != 'password123')
 if not tmp_res:
 msg.append("user %s has a weak password %s" %(data['name'], data['password']))
 res = res and tmp_res

 self.assertTrue(res, "\n".join(msg))

 def test_dummy(self):
 pass

if __name__ == '__main__':
 unittest.main()

运行及结果

在命令行中运行python test_password_4.py，结果如下

$ python test_password_4.py
before all test methods
.F
======================================================================
FAIL: test_week_password (__main__.WeakPasswordTeseCase1)
----------------------------------------------------------------------
Traceback (most recent call last):
 File "test_password_4.py", line 27, in test_week_password
 self.assertTrue(res, "\n".join(msg))
AssertionError: user tom has a weak password password123
user jerry has a weak password password

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

我们能学到什么

断言一旦失败之后测试方法就会结束运行，所以一般来说1个测试方法推荐只有1个断言
如果一个测试方法里面必须要有多个断言，那么要确保前面的断言失败之后，后面的断言就算不运行也不会影响测试的范围和结果
for循环中的断言一旦失败，for循环就退出了
上面演示的测试用例写法其实具备了一定的数据驱动测试的思想

原始封面

5. 字符串和文本

Fri, 03 Nov 2017 08:17:22 +0800

什么是字符串

目前为止我们已经打印了不少的字符串了。那么什么是字符串呢?

在python里，字符串往往表现为用单引号''或者是双引号""包裹起来的一些文字。这些文字便于人类阅读，往往可以展示给我们程序的用户阅读。

下面代码里s1,s2都是字符串。


s1 = '本次测试覆盖了100个模块'
s2 = "本次测试运行了100个用例"

f-string

我们经常需要在字符串中包含一些变量，这样可以让字符串变得更加动态，不同变量的取值可以生成不同的字符串。

python 3.6 之后引入了f-string的概念，可以非常方便的在字符串中包含变量。比如下面的例子。


module_count = 3
f"本次测试覆盖了{module_count}个模块"

另外python还支持.format()语法，我们后面通过代码去理解

背景

这一节里，我们把上一节的内容使用f-string来重新实现一下，逻辑和输出保持不变，用开发领域的术语来说，叫做"重构"。

代码实现

新建名为report_with_f_string.py，内容如下

# 打印出本次测试的测试结果
# A: 27/30 B: 40/40 C: 30/30
module_count = 3

case_count_of_module_a = 30.0
success_case_count_of_module_a = 27

case_count_of_module_b = 40.0
success_case_count_of_module_b = 40

case_count_of_module_c = 30.0
success_case_count_of_module_c = 30

print(f"本次测试覆盖了{module_count}个模块")
print(f"测试用例总数为: {case_count_of_module_a + case_count_of_module_b + case_count_of_module_c}")
print(f"执行的测试用例总数为: {case_count_of_module_a + case_count_of_module_b + case_count_of_module_c}")
print(f"用例最多的模块是B模块，B模块比A模块多出的用例数为: {case_count_of_module_b - case_count_of_module_a}")
print(f'A模块执行成功{success_case_count_of_module_a}个用例，执行失败的用例数为{case_count_of_module_a - success_case_count_of_module_a}')
print('A模块用例通过率为百分之{}'.format(success_case_count_of_module_a / case_count_of_module_a * 100))
print('B模块的用例全部执行通过， 通过率为百分之{}'.format((success_case_count_of_module_b / case_count_of_module_b) * 100))
print('C模块的用例全部执行通过， 通过率为百分之{}'.format((success_case_count_of_module_b / case_count_of_module_b) * 100))

test_type = '回归测试'
test_result = '不通过'

# 结束打印
print(test_type + test_result)

运行

在命令行中使用下面的命令去执行代码

$python report_with_f_string.py

你应该可以看到

如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

本次测试覆盖了3个模块
测试用例总数为: 100.0
执行的测试用例总数为: 100.0
用例最多的模块是B模块，B模块比A模块多出的用例数为: 10.0
A模块执行成功27个用例，执行失败的用例数为3.0
A模块用例通过率为百分之90.0
B模块的用例全部执行通过， 通过率为百分之100.0
C模块的用例全部执行通过， 通过率为百分之100.0
回归测试不通过

常见问题

为什么有时候字符串用单引号有时候又用双引号？一般情况下用双引号就足够了，不过有时候我们需要打印出单引号，这时候把单引号放到双引号内就可以了,反之亦然。

原始封面

5.参数化的Fixture

Mon, 30 Oct 2017 07:22:42 +0800

背景

继续上一节的测试需求，在上一节里，任何1条测试数据导致断言不通过后测试用例就会停止运行，这样每次只能检查出1条不符合规范的数据，有没有什么办法可以一次性把所有的不符合结果都测出来呢？

这时候我们就需要用到参数化的fixture特性了

更新数据文件

新建users.test.json文件，内容如下

[
 {"name":"jack","password":"Iloverose"},
 {"name":"rose","password":"Ilovejack"}
 {"name":"tom","password":"password123"},
 {"name":"mike","password":"password"},
 {"name":"james","password":"AGoodPasswordWordShouldBeLongEnough"}
]

我们增加了2条用户信息，其中mike的密码是弱密码。

参数化fixture

参数化fixture允许我们向fixture提供参数，参数可以是list，该list中有几条数据，fixture就会运行几次，相应的测试用例也会运行几次。

参数化fixture的语法是

@pytest.fixture(params=["smtp.gmail.com", "mail.python.org"])

其中len(params)的值就是用例执行的次数

在fixture的定义中，可以使用request.param来获取每次传入的参数，如下:

@pytest.fixture(scope="module",
 params=["smtp.gmail.com", "mail.python.org"])
def smtp(request):
 smtp = smtplib.SMTP(request.param, 587, timeout=5)
 yield smtp
 print ("finalizing %s" % smtp)
 smtp.close()

上面的代码smtp fixture会执行2次
第1次request.param == 'smtp.gmail.com'
第2次request.param == 'mail.python.org'

实现用例

我们现在使用参数化fixtures来实现一次性检查出弱密码的用例。

新建文件test_user_password_with_params.py，内容如下:


import pytest
import json
users = json.loads(open('./users.test.json', 'r').read())

class TestUserPasswordWithParam(object):
 @pytest.fixture(params=users)
 def user(self, request):
 return request.param

 def test_user_password(self, user):
 passwd = user['password']
 assert len(passwd) >= 6
 msg = "user %s has a weak password" %(user['name'])
 assert passwd != 'password', msg
 assert passwd != 'password123', msg

上面的例子里，我们先把所有用户信息读到users变量里，注意users这时候是list类型，可以直接传入到fixture的params

运行及结果

运行

pytest test_user_password_with_params.py

结果

$ pytest test_user_password_with_params.py
========================================================================= test session starts =========================================================================
platform darwin -- Python 2.7.12, pytest-3.2.3, py-1.4.34, pluggy-0.4.0
rootdir: /Users/easonhan/code/testclass.net/src/pytest, inifile:
collected 5 items

test_user_password_with_params.py ..FF.

============================================================================== FAILURES ===============================================================================
_________________________________________________________ TestUserPasswordWithParam.test_user_password[user2] _________________________________________________________

self = <test_user_password_with_params.TestUserPasswordWithParam object at 0x10de1d790>, user = {'name': 'tom', 'password': 'password123'}

 def test_user_password(self, user):
 passwd = user['password']
 assert len(passwd) >= 6
 msg = "user %s has a weak password" %(user['name'])
 assert passwd != 'password', msg
> assert passwd != 'password123', msg
E AssertionError: user tom has a weak password
E assert 'password123' != 'password123'

test_user_password_with_params.py:15: AssertionError
_________________________________________________________ TestUserPasswordWithParam.test_user_password[user3] _________________________________________________________

self = <test_user_password_with_params.TestUserPasswordWithParam object at 0x10de1df50>, user = {'name': 'mike', 'password': 'password'}

 def test_user_password(self, user):
 passwd = user['password']
 assert len(passwd) >= 6
 msg = "user %s has a weak password" %(user['name'])
> assert passwd != 'password', msg
E AssertionError: user mike has a weak password
E assert 'password' != 'password'

test_user_password_with_params.py:14: AssertionError
================================================================= 2 failed, 3 passed in 0.05 seconds ==================================================================

稍微留意一下, 可以看出tom和mike使用了弱密码。总共运行了5个用例,3个成功,2个失败。

5. Containers

Wed, 25 Oct 2017 06:55:26 +0800

我们可以使用容器(containers)来限制定位范围，webium的containers特性可以让我们的定位代码更加干净容易理解，避免大规模的使用难懂晦涩的xpath。

考虑下面的页面结构，为了可以遍历每一个搜索结果，我们可以使用下面的代码

from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
from webium import Find, Finds, BasePage

class Vacancy(WebElement):
 title = Find(by=By.CLASS_NAME, value='vacancy_title')
 profession = Find(by=By.CLASS_NAME, value='vacancy_profession')
 location = Find(by=By.CLASS_NAME, value='vacancy_location')
 apply_button = Find(by=By.CLASS_NAME, value='vacancy_apply_button')


class VacanciesPage(BasePage):
 vacancies_list = Finds(Vacancy, By.XPATH, '//div[@id="careers-vacancies"]/div[@data-id]')

 def __init__(self):
 super(VacanciesPage, self).__init__(url='http://wargaming.com/en/careers/vacancies/')


if __name__ == '__main__':
 page = VacanciesPage()
 page.open()
 for vacancy in page.vacancies_list:
 # search by CLASS_NAME='vacancy_title' is performed within one node
 print('Title: ' + vacancy.title.text)

原始封面

收藏清单: python自动化测试工具最全资源汇总

Sun, 22 Oct 2017 08:19:06 +0800

Web UI test automation Web UI 自动化

libraries 各种库
- selenium webdriver - 浏览器自动化工具
- splinter - 简单的web自动化工具，让元素定位，表单提交等更加容易
- mechanize - 有状态可编程的浏览器
frameworks and wrappers 框架和封装
- py.saunter - 有主见的自动化测试框架，使用了selenium RC和webdriver api
- moz-web-qa - py.test的插件，为Mozilla的WebQA项目提供了额外功能
- testutils sst - A web test framework that uses Python to generate functional browser-based tests.
- wtframework - 让web测试可以配置的框架
- holmium.core - Page Object及其他工具库支持
- robotframework-selenium2library - Robot Framework的selenium扩展
- gocept.selenium - selenium RC的API, 适合编写基于WSGI, Plone, Zope 2, ZTK, or Grok 应用的测试用例
- webium - 基于python的一个Page Object实现
- robotframework-anywherelibrary - Robot Framework的扩展库，使用selenium2测试web应用，使用appium测试移动应用
- robotframework-pageobjects - 一个不错的Page Object实现，可以脱离robot framework单独使用。具体看这里
- elementium - 用jQuery风格的语法糖来实现浏览器的自动化测试用例
- slickqa - slick-webdriver-python 项目是python selenium binding的一个封装
- selene - Concise UI 测试用例，使用python实现支持Ajax,PageObjects和Widgets
- hitch - 编写基于service的应用的测试用例
- Needle - Needle是基于图片比对的测试工作，它可以对web应用的一部分进行截图，然后跟预期结果的图片进行比对
- PyPOM - PyPOM是另一个Page Object库，适用于Selenium和Splinter测试
- POM - POM是Page-Object-Model 微框架，目的是让Web UI测试更加简单，快速和有乐趣
- websmith - Web测试的一套DSL
- pages - 轻量的page object库和组建
- widgetastic - RedHat UI widget 组建框架
- navmazing - PageObjects based navigation from RedHat
- nightwatch - 基于python和selenium的UI 自动化测试框架. 灵感来源于nightwatch.js
extensions 扩展
- webdriver_manager - 主要目的是让不同版本的浏览器driver管理起来更加方便
- pytest_splinter - pytest spinter 和 selenium的集成
- lettuce_webdriver - Selenium webdriver 的 lettuce封装
- Browsermob Proxy - python的Browsermob Proxy封装
- FireRobot - 一个Firefox的扩展,让你可以更高效的编写基于robot framework的selenium用例
- pytractor - Python的selenium扩展，以便更好的测试angular.js应用
- Selenium-Requests - 扩展 Selenium WebDriver类，包含了Requests库的一些功能，可以更方便的处理cookie和请求头
- selenium-respectful - selenium的封装，可以并行访问站点

Mobile test automation 移动端自动化测试工具

appium - 开源的自动化测试框架，可以测试native/hybrid/mobile web应用。核心是基于webdriver协议进行了扩展
Winium.StoreApps - 开源的自动化测试用具，用来测试Windows Store应用，实现了Selenium Remote WebDriver
robotframework-androidlibrary - Robot Framework用来测试android应用的扩展库
robotframework-appiumlibrary - appium的RobotFramework扩展
robotframework-ioslibrary -Robot的ios测试扩展库
uiautomator - Android uiautomator的python封装, 支持 Android 4.1+
ATX - 智能机自动化测试工具. 支持 iOS, Android, WebApp 和游戏

Windows UI test automation Windows的UI测试工具

Winium.Desktop - 测试Windows应用(主要是基于WinForms和WPF平台)的自动化测试工具. 实现了Selenium Remote WebDriver协议
PyAutoGUI - 跨平台的GUI测试工具，支持通过python脚本控制键盘和鼠标
robotframework-autoitlibrary - Robot Framework的windows GUI测试扩展
autopy - 简单跨平台的GUI测试工具集
UISoup - 支持windows和MacOS平台的UI自动化(仅工作在x86平台)
pywinauto - 非常有python面向对象风格的GUI测试库，现已支持64位机器以及py2和py3
SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持python2.7

Unix \ Linux UI test automation

ldtp - 跨平台的linux GUI测试项目
fMBT - 支持多平台的python GUI测试库
SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持python2.7

MacOS UI test automation MacOS UI自动化测试工具

ATOMac - 通过Apple Accessibility API来测试Mac应用的python库
PyAutoGUI - 跨平台的GUI测试工具，支持通过python脚本控制键盘和鼠标
SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持python2.7

原始封面

（五）Jenkins 设置定时任务

Mon, 16 Oct 2017 12:00:11 +0800

每次都手动的构建项目显然不够方便，有时候需要定时地执行自动化测试脚本。例如，每天晚上定时执行 py_tests.py 文件来运行自动化测试项目。

设置定时任务

前面已经创建的 “python test project” 项目为例，单击项目左侧的 “配置” 选项，修改项目的配置。

找到 构建触发器 ，勾选 Build periodically 选项。

通过查看设置说明，此处定时任务的格式遵循 cron 的语法（可以与 cron 的语法有轻微的差异）。具体格式，每行包含五个字段，通过 Tab 或空格分隔。

字段	说明
MINUTE	Minutes within the hour (0–59)
HOUR	The hour of the day (0–23)
DOM	The day of the month (1–31)
MONTH	The month (1–12)
DOW	The day of the week (0–7) where 0 and 7 are Sunday.

若要指定一个字段的多个值，可以使用以下运算符，按先后顺序。

（五）Locust 参数说明

Mon, 16 Oct 2017 11:00:11 +0800

最时候该讲一下 locust 工具的参数了，虽然前面几节我们已经使用了不少参数，例如 “-f” 、“–host” 等。

Locust 参数

打开命令提示符（或Linux终端），输入 locust --help 。

> locust --help
Usage: locust [options] [LocustClass [LocustClass2 ... ]]

Options:
 -h, --help show this help message and exit
 -H HOST, --host=HOST Host to load test in the following format:
 http://10.21.32.33
 --web-host=WEB_HOST Host to bind the web interface to. Defaults to '' (all
 interfaces)
 -P PORT, --port=PORT, --web-port=PORT
 Port on which to run web host
 -f LOCUSTFILE, --locustfile=LOCUSTFILE
 Python module file to import, e.g. '../other.py'.
 Default: locustfile
 --csv=CSVFILEBASE, --csv-base-name=CSVFILEBASE
 Store current request stats to files in CSV format.
 --master Set locust to run in distributed mode with this
 process as master
 --slave Set locust to run in distributed mode with this
 process as slave
 --master-host=MASTER_HOST
 Host or IP address of locust master for distributed
 load testing. Only used when running with --slave.
 Defaults to 127.0.0.1.
 --master-port=MASTER_PORT
 The port to connect to that is used by the locust
 master for distributed load testing. Only used when
 running with --slave. Defaults to 5557. Note that
 slaves will also connect to the master node on this
 port + 1.
 --master-bind-host=MASTER_BIND_HOST
 Interfaces (hostname, ip) that locust master should
 bind to. Only used when running with --master.
 Defaults to * (all available interfaces).
 --master-bind-port=MASTER_BIND_PORT
 Port that locust master should bind to. Only used when
 running with --master. Defaults to 5557. Note that
 Locust will also use this port + 1, so by default the
 master node will bind to 5557 and 5558.
 --expect-slaves=EXPECT_SLAVES
 How many slaves master should expect to connect before
 starting the test (only when --no-web used).
 --no-web Disable the web interface, and instead start running
 the test immediately. Requires -c and -r to be
 specified.
 -c NUM_CLIENTS, --clients=NUM_CLIENTS
 Number of concurrent Locust users. Only used together
 with --no-web
 -r HATCH_RATE, --hatch-rate=HATCH_RATE
 The rate per second in which clients are spawned. Only
 used together with --no-web
 -t RUN_TIME, --run-time=RUN_TIME
 Stop after the specified amount of time, e.g. (300s,
 20m, 3h, 1h30m, etc.). Only used together with --no-
 web
 -L LOGLEVEL, --loglevel=LOGLEVEL
 Choose between DEBUG/INFO/WARNING/ERROR/CRITICAL.
 Default is INFO.
 --logfile=LOGFILE Path to log file. If not set, log will go to
 stdout/stderr
 --print-stats Print stats in the console
 --only-summary Only print the summary stats
 --no-reset-stats Do not reset statistics once hatching has been
 completed
 -l, --list Show list of possible locust classes and exit
 --show-task-ratio print table of the locust classes' task execution
 ratio
 --show-task-ratio-json
 print json data of the locust classes' task execution
 ratio
 -V, --version show program's version number and exit

参数说明：

05. 安装环境：Mac

Mon, 16 Oct 2017 08:00:11 +0800

Mac 系统下安装 IntelliJ IDEA

系统要求

系统支持：Mac OS X 10.5 以上

JDK 版本：Apple Java 6 或 Oracle Java 7 以上

内存：最低要求 1 G，推荐 2 G 以上

硬盘：最低要求 2 G

显示器：最低要求 1024 X 768 分辨率

更多信息可以阅读：https://www.jetbrains.com/idea/download/system_requirements.jsp?os=mac

重要说明

我这里以 Mac 系统为例进行讲解。但是，在学习下面内容之前请先看下章节：Windows 下安装

因为它们配置流程是基本一样的，只是系统不同，开始的步骤不太一样而已，因此相同部分我这里是不会再讲的，我只讲 IntelliJ IDEA 在 Mac 安装特殊的地方。

Mac 下安装过程

运行下载到 ideaIU-14.1.4.dmg，效果如上图所示。

根据提示把左侧的 IntelliJ IDEA 图标拖动到右侧目录图

（五）soapUI创建SOAP项目

Wed, 20 Sep 2017 22:00:11 +0800

创建 SOAP 项目

打开 soapUI 工具。创建一个SOAP项目。

在窗口左侧导航栏，右键 Projects –> New SOAP Project。

添加SOAP接口

以国内手机号码归属地查询接口为例：

Project Name：MobileCodeWS为项目名称。

Initial WSDL：http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?wsdl 为接口URL。

点击 OK 按钮，创建项目完成。

依次展开：MobileCodeWS–>MobileCodeWSSoap–>getMobileCodeInfo/，双击 Request 1，填写接口查询的手机号。如下图。

请求接口详细配置如下：

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:web="http://WebXml.com.cn/">
 <soapenv:Header/>
 <soapenv:Body>
 <web:getMobileCodeInfo>
 <!--Optional:-->
 <web:mobileCode>186xxxxxxxx</web:mobileCode>
 <!--Optional:-->
 <web:userID></web:userID>
 </web:getMobileCodeInfo>
 </soapenv:Body>
</soapenv:Envelope>

注：将 xxxxxxxx 替换为手机号。

运行测试

点击 Request 1 窗口左上角的绿色运行按钮，发送 SOAP 请求。右侧窗口将会显示接口返回结果。

appium新手入门（5）—— python-client安装与测试

Thu, 07 Sep 2017 10:24:12 +0800

关联阅读：

appium新手入门（1）—— appium介绍

appium新手入门（2）—— 安装 Android SDK

appium新手入门（3）—— 安装 appium Server

#### 前提条件 ----

当你点击这一章时，说明你是打算使用 Python 语言编写 appium 自动化测试脚本的。

1、安装 Python 语言 , Python的安装相对相简单得多。

2、Python 编辑器很多，推荐：PyCharm、Atom、Sublime text3等。这几款都是我常用的。

安装 python-client

其实，python-client 的项目名称叫：Appium-Python-Client。

推荐pip安装：

(venv) λ pip install Appium-Python-Client
Collecting Appium-Python-Client
 Using cached Appium-Python-Client-0.24.tar.gz
Requirement already satisfied: selenium>=2.47.0 in d:\pyflask\venv\lib\site-packages (from Appium-Python-Client)
Building wheels for collected packages: Appium-Python-Client
 Running setup.py bdist_wheel for Appium-Python-Client ... done
 Stored in directory: C:\Users\fnngj\AppData\Local\pip\Cache\wheels\2e\cf\10\0e3f177c9869147b16584d402f79d9007df1139105ea3ecc2c

Successfully built Appium-Python-Client
Installing collected packages: Appium-Python-Client
Successfully installed Appium-Python-Client-0.24

#### 运行第一个Appium测试 ---- * __第一步__，启动Android模拟器。

5.3A原则

Sat, 26 Aug 2017 04:41:43 +0800

3A原则原本是单元测试用例编写时应该遵循的基本原则，不过我们可以扩展到接口的自动化测试用例编写中来。

我们首先看一下3A原则在每一层自动化测试中的具体应用。

单元测试用例

Arrange: 初始化测试对象或者准备测试数据
Act : 调用被测方法
Assert: 断言

给一个例子(c#)

[TestMethod] 
public void Withdraw_ValidAmount_ChangesBalance() 
{ 
 // arrange 
 double currentBalance = 10.0; 
 double withdrawal = 1.0; 
 double expected = 9.0; 
 var account = new CheckingAccount("JohnDoe", currentBalance); 
 // act 
 account.Withdraw(withdrawal); 
 double actual = account.Balance; 
 // assert 
 Assert.AreEqual(expected, actual); 
}

服务间的接口测试用例

服务间的接口测试实际上是黑盒测试，3A原则也适用于这种测试用例的编写

A: arrange 初始化测试数据，就是造数据，这里的数据有我们输入的数据，也有目标接口所涉及的资源，比如hr系统中的用户信息，我们必须先有几条人员的详细信息才能去测获取人员信息的接口（当然只是正常的流程，我们有时候还需要清掉数据以便测试资源为空的情况）；
A: act 调用接口，传入输入数据；
A: assert 断言，对返回的资源信息进行断言，比如获取用户信息的接口返回了用户信息之后，我们要判断返回的用户是不是我们想要的那个用户，我们获取的是李雷的信息，接口如果返回韩梅梅，那么接口的逻辑就是不对的；

举个例子(python)

def test_get_task_by_id(self):
# arrange
 create_task_res = self.create_task('test', 'desc')
 new_id = create_task_res['id']

 # act
 url_for_get_by_id = self.ip + '/api/tasks/' + str(new_id)
 res = requests.request("GET", url_for_get_by_id).json()

 # assert
 self.assertEqual(res['id'], new_id)

手工测试用例

手工的功能测试用例也可以用3A原则来编写。

Arrange: 准备被测功能相关的测试数据，比如往系统里录入一批工单以便测试工单的分页功能
Act : 调用被测的功能，实际上这就是我们一直讲的测试步骤
Assert: 断言

举个例子

# arrange and act
打开chrome浏览器并跳转至http://localhost/wordpress/wp-login.php
在用户名文本框中输入admin
在密码文本框中输入admin
点击登陆按钮
# assert
浏览器跳转到http://localhost/wordpress/wp-admin/
右上角出现“你好，admin”字样

总结

总之对于接口的自动化测试用例说来，遵循3A原则就意味着

JMeter官方文档：5. 构建一个高级web测试计划

Thu, 24 Aug 2017 12:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

5. 构建一个高级web测试计划

在本章，你将学习如何创建高级测试计划，来测试一个web网站。

有关基础测试计划的示例，请参考构建Web测试计划

5.1 使用URL重写用户session

如果你的 Web 应用程序，是使用URL重写而不是使用cookie保存session信息，那么你将需要做一点额外的设置来测试你的网站。

为了争取响应URL重写，JMeter 需要解析从服务器接受的 HTML，并检索唯一的 sessionID。

使用恰当的 HTTP URL 重写修改器来完成这项工作。只需要将sessionID参数名输入到修改器，jmeter会找到它并将它添加到每个请求中。如果请求已经有这个参数值，则会替换它。如果勾选Cache Session id?复选框，那么最后找到的sessionID将被保存，如果先前的http示例不包含sessionID，则会使用它。

URL重写修改器示例

下载这个示例。图1 显示一个使用URL重写的测试计划。注意，URL重写修改器被添加到事务控制器中，因此它只会影响该事务控制器下的请求。

图1 测试树

在图2 中，我们看到URL重写修改器的GUI界面，它有一个字段是供用户修改指定sessionID的。还有一个复选框，用于标记sessionID是地址的一部分（由“；”分隔），而不是作为请求参数。

图2 请求参数

5.2 使用头文件管理器

Jmeter的 HTTP头文件管理器，允许您自定义HTTP请求头文件，这个头文件包括“User-Agent"，“Pragma”, “Referer"等属性。

HTTP 头文件管理器，和 HTTP cookie 管理器类似，应该在线程组级别添加，除非出于特殊原因，您希望在测试中给某几个 HTTP 请求设置不一样的头文件。

appium简明教程（5）——appium client方法一览

Wed, 16 Aug 2017 07:30:01 +0800

appium client扩展了原生的webdriver client方法

下面以java代码为例，简单过一下appium client提供的适合移动端使用的新方法

resetApp()
getAppString()
sendKeyEvent()
currentActivity()
pullFile()
pushFile()
pullFolder()
hideKeyboard()
runAppInBackground()
performTouchAction()
performMultiTouchAction()
tap()
swipe()
pinch()
zoom()
getNamedTextField()
isAppInstalled()
installApp()
removeApp()
launchApp()
closeApp()
endTestCoverage()
lockScreen()
shake()
complexFind()
scrollTo()
scrollToExact()
openNotifications()
Context Switching: .context(), .getContextHandles(), getContext())

新增的locator

findElementByAccessibilityId()
findElementsByAccessibilityId()
findElementByIosUIAutomation()
findElementsByIosUIAutomation()
findElementByAndroidUIAutomator()
findElementsByAndroidUIAutomator()

这些方法主要覆盖了3大类：

driver扩展：比如增加了resetApp等操作app的方法
action扩展：增加一些移动端的特有的action（怎么描述呢，相当于是移动端特有的操作），比如swipe，shake(嗯，有了这个方法就可以让代码帮你摇一摇了)等；
locator扩展：增加了一些移动端专属的定位策略

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

原始封面

性能测试基础（五）响应时间

Fri, 11 Aug 2017 11:59:11 +0800

站在用户角度来说，你可以将软件性能看作是软件对用户操作的响应时间。说得更明直白点，对用户来说，当单击一个按钮或链接，从用户单击开始到应用系统把本次操作的结果以用户识别的方式展示出来，这个过程所消耗的时间就是用户对软件性能的直观印象。

#### 响应时间过程分析:

我们需要对这个过程进行分解，才能得到你真正想要的响应时间。我把整个过程分三个部分：呈现时间，数据传输时间和系统处理时间。

呈现时间

其实主要说的浏览器对接收到数据的一个处理展示的过程。几年前大家都在用IE，如果页面显示比较慢，我们肯定不会怪罪IE，只会怪罪电信运营商的网速或被访问的系统（其实，大多情况我们不会考虑是被访问系统的问题）。现在Chrome来了，我们会发现同一台电脑同一个网站，通过Chrome去访问，页面的呈现速度会比IE略快。这是各种评测及大众用户的整体感受。

当然，我说这个呈现时间不能全怪在浏览器的身上，当然还和承载它的操作系统有关，以及电脑硬件（比如CPU、内存）。假如你有超快的浏览器，如果是一台配置很低的电脑上运行，当你多打开几个网页就有可能使电脑卡死。

数据传输时间

千万不要忽视数据传输时间。如果你要寄信给你一个远方的朋友，你想是什么影响你朋友收到信的时间的？不是你写信的过程（如果你写的信不像书一样厚的话），也不是你朋友读信的过程，而是送信的过程。

拿我们系统的数据传输过程来说，我们发送一个请求需要时间，系统处理完后返回给我们也需要时间。初学性能测试工具的同学喜欢拿工具去测试互联网上的一些系统，甚至不懂性能的同学认为可以用性能测试工具将互联网上的一些网站宕机。

那么，我觉得这些同学应该补补网络知识了，你的带宽是多少？互联网是个网，就是算是相同的起点与终点，它有可能走的不同的路线。有没有考虑网络延迟？就算你的发出请求都能成功的发出，但到目的地的时候，已经不能叫并发了。

这也是为什么我们在一般做性能测试时，一般要强调要在局域网中进行。当然，有些性能测试需要在互联网中时行。但它们重点不是验证服务器端的最大处理能力。

系统处理时间

当系统得到请求后会对请求进行处理并将结果返回。那我进行性能测试主要就是验证系统的处理时间，因为前面的呈现时间和数据传输时间都是我们不可控制的，用户使用的电脑及浏览器千差万别，用户的网络状况千差万别。我们唯一能控制的就是将系统的处理请求的时间缩到最短。一般性能测试场景

听了上面的分析，貌似每个过程都挺“浪费”时间，那么我们如何只测试系统的处理时间呢？

一般测试工具都屏蔽响应的呈现过程，只是模拟多用户并发请求，计算用户得到响应的时间，不会将服务器的每个响应做客户端渲染呈现。

对于数据传输的问题，这也是我要强调的性能测试要在局域网中进行，在局域网中一般不会受到数据带宽的限制。所以，可以对数据的传输时间忽略不计。

原始封面

（五）通过name去定位页面上的元素

Wed, 09 Aug 2017 01:45:25 +0800

表单元素

一般来说表单元素的标签大多出现在<form></form>标签中，比如

<input type="text">: 单行文本框
<input type="checkbox">: checkbox
<input type="radio">: radio
<select><option></option></select>: 下拉框
<textarea></textarea>: 多行文本

如果这样元素有name属性的话，建议使用name属性去定位，因为相比较其他属性，name属性更加稳定。

有一些元素比如checkbox和radio往往有多个name属性相同的元素，如下面的html代码所示

<ul class="list list--bare">
 <li><label for="radio1"><input id="radio1" name="radio" type="radio" class="radio" checked="checked"> Option 1</label></li>
 <li><label for="radio2"><input id="radio2" name="radio" type="radio" class="radio"> Option 2</label></li>
 <li><label for="radio3"><input id="radio3" name="radio" type="radio" class="radio"> Option 3</label></li>
</ul>

这时候也可以使用name属性定位，不过需要用到后面讲的定位一组元素的知识了。

目的

熟悉selenium webdriver 定位方式
学会通过name属性去定位元素

示例代码

// <input name="username" />
dr.findElement(By.name('username')).sendKeys('测试教程网');


// <input name="password" type="password" />
dr.findElement(By.name('password')).sendKeys('就不告诉你');

原始封面

java测试笔试题1

Wed, 26 Jul 2017 09:30:25 +0800

final关键字可以修饰类吗？

can keyword final be assigned to a class? yes

可以

Java可以继承多父类么？可以实现多接口么？

Can a java class inheritance from multiple classes? how about a java class implement multiple interfaces?

不可以多继承，但是可以多实现

构造方法是否可以重写和重载？

Can a constructor be overrided? how about oveload?

不可以重写，可以重载

Exception类的父类是？

what is the Exception class inhertanced from?

Throwable

同一个类中，静态方法如何直接调用非静态方法？

Could a static method call a non-static method in the same class?

静态方法不可以调用非静态方法

原始封面

（五）浅谈测试用例

Sat, 22 Jul 2017 12:59:11 +0800

通俗的讲：就是把我们测试系统的操作步骤用按照一定的格式用文字描述出来。

#### 二、写测试用例有什么好处？ ---- * 理清思路，避免遗漏

跟踪测试进展

通过编写测试用例，执行测试用例，我们可以很清楚的知道我们的测试进度。

历史参考

在我们所做的项目中，也许会有很多功能是相同或相近的，我们对这类功能设计了测试用例，便于以后我们遇到类似功能的时候可以做参考依据。

重复性

我们测试一个系统不是一个人测一遍就算测完的，需要多人反复的进行测试，那么我们就需要测试用例来规范和指导我们的测试行为。

等价类划分

有效等价类： 输入满足程序输入的要求（来自规格说明书），通俗的说就是正确的输入。

无效等价类： 输入不满足程序输入的要求，即异常输入，需要系统对此有一定的容错性。

例如：

一个输入框要求输入1-10000的数字

有效等价类：可以输入1-10000之间的数来验证，如：2、5、99、8495……

无效等价类：可以输入1-10000之外的任意字符验证，如：0、10001、字母、下划线、特殊符号、空格、回车…..

边界值

因果图

错误推测法

基于经验和直觉推测出系统可能存在的错误，从而有针对性的设计测试用例的方法。

其它

设计测试用例的方法有很多，我们常用就上面几种，其它的方法还有：状态迁移图、流程分析法、正交验证法等等。

#### 四、测试用例的格式与要素 ---- 一个测试用例应该包括：编号，标题，测试场景，测试步骤，预期结果。

当然还可加入一些它选项，如：优先级、测试阶段….

编号：

标题:

测试环境：

测试步骤：

预期结果：

关于测试用例的存放管理：

2、通过world\Excel文档形式管理，这样的好处就是自己定义测试用例的格式。

面来看一个具体的测试用例。我们会有更深刻的认识。

编号：001

标题: 系统登录测试用例

测试环境：
Windows 10/Chrome 58


测试步骤：
1、打开浏览器，输入系统网站，打开登录页面。
2、用户名密码为空，点击登录按钮
3、输入用户名，密码为空，点击登录按钮。
4、用户名为空，输入密码，点击登录按钮。
5、用户名正确，密码错误，点击登录按钮。
....


预期结果：
1、成功打开首页。
2、系统提示：用户名密码不能为空。
3、系统提示：密码不能为空。
4、系统提示：用户名不能为空。
5、系统提示：用户名或密码错误。
....

原始封面

（五）selenium元素定位

Tue, 04 Jul 2017 07:37:11 +0800

### selenium定位方法

Selenium提供了8种定位方式。

id
name
class name
tag name
link text
partial link text
xpath
css selector

这8种定位方式在Python selenium中所对应的方法为：

findElement(By.id())
findElement(By.name())
findElement(By.className())
findElement(By.tagName())
findElement(By.linkText())
findElement(By.partialLinkText())
findElement(By.xpath())
findElement(By.cssSelector())

### 定位方法的用法

假如我们有一个Web页面，通过前端工具（如，Firebug）查看到一个元素的属性是这样的。

<html>
 <head>
 <body link="#0000cc">
 <a id="result_logo" href="/" onmousedown="return c({'fm':'tab','tab':'logo'})">
 <form id="form" class="fm" name="f" action="/s">
 <span class="soutu-btn"></span>
 <input id="kw" class="s_ipt" name="wd" value="" maxlength="255" autocomplete="off">

我们的目的是要定位input标签的输入框。

通过id定位:

driver.findElement(By.id("kw"))

通过name定位:

driver.findElement(By.name("wd"))

通过class name定位:

driver.findElement(By.className("s_ipt"))

通过tag name定位:

driver.findElement(By.tagName("input"))

通过xpath定位，xpath定位有N种写法，这里列几个常用写法:

driver.findElement(By.xpath("//*[@id='kw']"))
driver.findElement(By.xpath("//*[@name='wd']"))
driver.findElement(By.xpath("//input[@class='s_ipt']"))
driver.findElement(By.xpath("/html/body/form/span/input"))
driver.findElement(By.xpath("//span[@class='soutu-btn']/input"))
driver.findElement(By.xpath("//form[@id='form']/span/input"))
driver.findElement(By.xpath("//input[@id='kw' and @name='wd']"))

通过css定位，css定位有N种写法，这里列几个常用写法:

driver.findElement(By.cssSelector("#kw")
driver.findElement(By.cssSelector("[name=wd]")
driver.findElement(By.cssSelector(".s_ipt")
driver.findElement(By.cssSelector("html > body > form > span > input")
driver.findElement(By.cssSelector("span.soutu-btn> input#kw")
driver.findElement(By.cssSelector("form#form > span > input")

接下来，我们的页面上有一组文本链接。

（五）WebDriver常用方法

Mon, 26 Jun 2017 12:59:11 +0800

### 点击和输入前面我们已经学习了定位元素，定位只是第一步，定位之后需要对这个元素进行操作，或单击（按钮）或输入（输入框），下面就来认识 WebDriver 中最常用的几个方法：

clear()：清除文本。
send_keys (value)：模拟按键输入。
click()：单击元素。

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.baidu.com")

driver.find_element_by_id("kw").clear()
driver.find_element_by_id("kw").send_keys("selenium")
driver.find_element_by_id("su").click()

driver.quit()

### 提交

submit()

submit()方法用于提交表单。例如，在搜索框输入关键字之后的“回车” 操作，就可以通过该方法模拟。

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.baidu.com")

search_text = driver.find_element_by_id('kw')
search_text.send_keys('selenium')
search_text.submit()

driver.quit()

有时候 submit()可以与 click()方法互换来使用， submit()同样可以提交一个按钮，但 submit()的应用范围远不及 click()广泛。

### 其他常用方法

size：返回元素的尺寸。
text：获取元素的文本。
get_attribute(name)：获得属性值。
is_displayed()：设置该元素是否用户可见。

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("http://www.baidu.com")

# 获得输入框的尺寸
size = driver.find_element_by_id('kw').size
print(size)

# 返回百度页面底部备案信息
text = driver.find_element_by_id("cp").text
print(text)

# 返回元素的属性值， 可以是 id、 name、 type 或其他任意属性
attribute = driver.find_element_by_id("kw").get_attribute('type')
print(attribute)

# 返回元素的结果是否可见， 返回结果为 True 或 False
result = driver.find_element_by_id("kw").is_displayed()
print(result)

driver.quit()

输出结果：

软件测试分工

Tue, 17 Jun 2025 17:29:15 +0800

按照本文的主题还是来谈谈软件测试人员的分工吧！主要来谈传统软件测试过程中的测试分工。

集体测试

也许专业测试里讲这种方式，很可能不叫“集体测试”。因为我根据的自己的理解起了大概符合意思的名词叫集体测试“集体测试”。

这种测试模式就是，公司里所有的测试人员抱成一团儿，来一个项目，所有测试人员就集中测试一个项目。

先说这种分工方式的优点：

1、因为测试团队的中每个成员有都有优缺，人员在工作之中相互取长补短。可以很快的找出软件中的缺陷。三个臭皮匠顶一个诸葛亮，一个经验再丰富的测试不一定有三个水平一般的测从员发现的问题多。

2、人多的另一个好处是测试项目能可以在更快的时间内发现更多的缺陷。总结一下就是更短时间内发现更多的问题。

再来说说这种方式的缺点：

1、一个人员一张嘴，人力成本很高（人员工资，人员平均时间投入，测试机等硬件资源投入）。

2、当同时需要测试多个项目中时，不好意思，按顺序来，请在后面排好队。（并发能力不足）

3、工作重复，同样一个缺陷，很可能同时被所有测试员发现，或者叫重复率很高。

4、人员水平难以区分，在一个项目测试过程中，有的测人员可能一个缺陷也没找到，有的测试人员却发现了几乎所有的问题。也许这个项目一个缺陷也没找到的测试员在下个项目中却发现了很多缺陷。（混入南郭先生）

5、发现了漏测现象是整个测试团队的责任。（这也不是明确的缺点，要看团队的氛围是积极的还是消极的。）

好吧！集体测试缺点太多，就像国家成立初期的“吃大锅饭”，肯定是阻碍发展的。那我们来看看几种分工方式。

#### 按测试内容分工 ---

一个项目的测试包括文档测试，易用性测试，逻辑功能测试，界面测试，配置和兼容等多个方面。我们可以根据人员的特点为每个人员分配不同的测试内容。

内容分工方式的优点：

1、分工明确，每位人员都清楚自己的测试的内容重点。

2、责任到位，通过漏测的缺陷就可明确是谁的责任。

#### 按测试流程划分 ----

我们的项目测试流程一般需要，制定测试计划，编写测试用例，执行测试用例，输出测试报告等工作，我们可以根据流程中的各个阶段来进行划分。

不同的测试人员负责不同测试阶段的工作。

优点：

1、流程清晰，就像瀑布试项目开发流程，不同阶段的工作由不同的人员担任。

2、划分流程的每个阶段难易程度和所需要的技能。

编写测试计划人员需要对整个项目的工作时间、资源分配，测试内容，实施过程有整体的把控能力。

用例辨析人员，需要对项目需求，测试方法，测试点有深入的了解。

用例执行人员需要细心，使用缺陷系统，沟通，协助研发定位缺陷。

输出测试报告人员需要对项目的测试过程，缺陷数量，类型，分布。用例执行请况等进行统计。也可以由测试执行人员担任。

#### 按项目模块划分 ---- ![](http://img.testclass.net/module_test.png)

对中大型的项目，这种划分就非常必要了，项目的模块非常多，功能也非常多。不同的测试人员负责不同模块的功能测试，这样会使用测试工作变得更加清晰。

1、人员利用率高，为什么这么说呢? 不同的人员负责的功能不一样。工作就不会存在交叉与重复。

2、更容易挖掘深度缺陷，假如A人员今天测试这个功能，明天测试那个功能，他就不可能对被测功能内部逻辑与业务有深入有了解。找到的也只是很表面的缺陷。那么如果一个人员长期负责一个模块的功能，那么就会更容易发现更有深度的缺陷。而往往深度的缺陷是致命的。

#### 按照测试类型分工 ----

我们知道软件除了功能需要测试以外，软件在编码阶段需要单元测试，接口测试等，在系统测试阶段，为提高功能测试的效率，可能对某些模块进行功能自动化，我们还要考虑软件的性能、安全性等问题。这些类型也是我项目中最常见的分类。我们可以根据这些类型为测试人员分配测试工作。当然，其专业性对测试人员的要求也比较高。

python简明教程: 6. 模块

Sat, 17 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 6. 模块
####################################################

# 你可以导入1个模块
import math

print math.sqrt(16) # => 4

# 可以从module里导入一些函数
from math import ceil, floor

print ceil(3.7) # => 4.0
print floor(3.7) # => 3.0

# 可以把模块里所有的函数都导出来
# 注意: 这是不推荐的做法
from math import *

# 模块名是可以有简写的
import math as m

math.sqrt(16) == m.sqrt(16) # => True
# 你也可以测试这些函数是否相等
from math import sqrt

math.sqrt == m.sqrt == sqrt # => True

# python的模块就是普通的python文件.
# 你可以创建自己的模块，然后进行导入
# 模块就是文件的文件名

# 你可以找出模块里定义了哪些函数和属性
import math

dir(math)

# 如果你有1个名为math.py的文件
# 并且该文件跟你的脚本在同一文件夹下
# 你导入math.py的时候你将导入自己定义的版本
# 而不是python标准库的math模块
# 这是因为本地文件夹的导入优先级高于标准库

原始封面

（六）创建Nginx容器

Mon, 22 Jan 2018 14:38:11 +0800

获取Nginx镜像

最简单的方法就是通过 docker pull nginx 命令来创建 Nginx容器。

$ sudo docker pull nginx

或者：

$ sudo docker pull registry.docker-cn.com/library/nginx

其中 registry.docker-cn.com 为国内的官方镜像仓库，速度要好很多。

启动Nginx容器

查看镜像：

$ sudo docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu latest 2a4cca5ac898 8 days ago 111MB
registry.docker-cn.com/library/nginx latest 3f8a4339aadd 4 weeks ago 108MB
hello-world latest f2a91732366c 2 months ago 1.85kB

启动 ngnnx 容器

$ sudo docker run --name some-nginx -d -p 8080:80 registry.docker-cn.com/library/nginx

b5bbf1dfe86a21d641a161c05598c0f4f4d4b32fc8d756b6fdf306295067625f

-name 指定启动容器的名称为 some-nginx。
-d 让Docker容器在后台以守护态（Daemonized）形式运行。

（六）Package 和 Import

Wed, 17 Jan 2018 14:36:11 +0800

除非你写的代码超级简单，如：打印。大多数情况情，必须会导入依赖的类。这些类大体上分三类：

由我们自己创建的类。
由Java JDK提供的类。
由第三方库或框架提供。

package

其实， package 名称就像是我们的姓，而 class 名称就像是我们的名字。package 名称有很多点号“ . ”，就好像是复姓。比如说java.lang.String，就是复姓 java.lang，名字为 String 的类别。

Java 会使用package这种机制的原因也非常明显，就像我们取姓名一样，光是一间学校的同一届同学中，就有可能会出现不少同名的同学，如果不取姓的话，那学校在处理学生资料，或是同学彼此之间的称呼，就会发生很大的困扰。幸运的是，Java 的套件名称我们可以自己取，不像人的姓没有太大的选择，如果依照 Sun 的规范来取套件名称，那理论上不同人所取的套件名称不会相同 ( 请参阅 “命名惯例"的相关文章 )，也就不会发生名称冲突的情况。

如，我们可以用下面的方法使用 Selenium 的相关包。

public class JavaPackage {

 public static void main(String[] args) {
 org.openqa.selenium.WebDriver driver = new org.openqa.selenium.chrome.ChromeDriver();
 // ……
 }
}

import

显然上面的例子使编程变得很麻烦，我想使用某个类或方法，就不得写又臭又长的“复姓” 。于是，Sun（Sun 公司目前已被 Oracle 公司收购）想到了一个方法用 import 来优雅的解决这个问题。这个 import 就是在程式一开头的时候，先说明程式中会用到那些类别的简称，也就是只称呼名字，不称呼他的姓。姓在程序开头声明。

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;


public class JavaImport {

 public static void main(String[] args) {
 WebDriver driver = new ChromeDriver();

 //……
 }

}

原始封面

TDD实战（六）“井字游戏” 需求四

Mon, 08 Jan 2018 12:40:11 +0800

需求4

如果出现平局如何处理。

所有格子都占满则为平局。

测试用例1

可以通过填满棋盘的所有格子测试平局结果。

@Test
public void whenAllBoxesAreFilledThenDraw(){
 ticTacToe.play(1,1); //X
 ticTacToe.play(1,2); //O
 ticTacToe.play(1,3); //X
 ticTacToe.play(2,1); //O
 ticTacToe.play(2,3); //X
 ticTacToe.play(2,2); //O
 ticTacToe.play(3,1); //X
 ticTacToe.play(3,3); //O
 String actual = ticTacToe.play(3,2); //X
 assertEquals("The result is draw", actual);
}

实现测试1

检查是否为平局非常简单 — 只需要检查是否已占满整个棋盘，所以，可以通过遍历数组board实现。

public String play(int x, int y){
 checkAxis(x);
 checkAxis(y);
 lastPlayer = nextPlayer();
 setBox(x, y, lastPlayer);
 if(isWin()){
 return lastPlayer + " is the winner";
 }else if(isDraw()){
 return "The result is draw";
 }else {
 return "No winner";
 }
}

private boolean isDraw(){
 for(int x = 0; x < SIZE; x++){
 for(int y = 0; y < SIZE; y++){
 if(board[x][y] == '\0'){
 return false;
 }
 }
 }
 return true;
}

** 执行测试用例1 检查它是否运行通过。

Android测试（六）：Android UI自动化测试

Wed, 20 Dec 2017 14:30:12 +0800

原文：https://developer.android.com/training/testing/ui-testing/index.html

用户界面（UI）测试可以确保你的应用程序满足其功能要求，并达到用户最可能成功采用的高质量标准。

UI测试的一种方法是简单地让人类测试人员在目标应用程序上执行一组用户操作，并验证其行为是否正确。但是，这种手动方法可能耗时、乏味、且容易出错。更有效的方法是编写您的UI测试，以便用户操作以自动方式执行。自动化方法使您能够以可重复的方式快速可靠地运行测试。

注意：强烈建议您使用Android Studio来构建测试应用程序，因为它提供了项目设置，包含库和包非常方便。这个里假定你正在使用Android Studio。

要使用Android Studio自动执行UI测试，请在单独的Android测试文件夹src/androidTest/java中实现测试代码。针对Gradle的Android插件将根据你的测试代码构建测试应用程序，然后将测试应用程序加载到与目标应用程序相同的设备上。在测试代码中，可以使用UI测试框架来模拟目标应用程序上的用户交互，以执行覆盖特定使用场景的测试任务。

为了测试Android应用程序，通常会创建这些类型的UI自动化测试：

单个应用程序的UI测试： 这种类型的测试验证当用户执行特定操作或在其活动中输入特定内容时，目标验证应用程序的行为是否符合预期。它允许你检查目标应用程序是否返回正确的UI输出，以响应应用程序活动中的用户交互。像Espresso这样的UI测试框架允许以编程方式模拟用户操作并测试复杂的应用内用户交互。

跨越多个应用程序的UI测试： 这种类型的测试验证不同用户应用程序之间或用户应用程序与系统应用程序之间交互的正确行为。例如，可能想要测试你的相机应用程序与第三方社交媒体应用程序或默认的Android照片应用程序正确共享图像。支持跨应用程序交互的UI测试框架（如UI Automator）允许你为这些方案创建测试。

本课的经验将告诉你如何使用Android测试支持库中的工具和API来构建这些类型的自动化测试。在开始使用这些API构建测试之前，你必须安装Android测试支持库，如下载Android测试支持库中所述。

课程

Testing UI for a Single App（单个应用程序的UI测试）

了解如何使用Espresso测试框架在单个应用程序中测试UI。

Testing UI for Multiple Apps （多个应用程序的UI测试）

了解如何使用UI Automator测试框架在多个应用程序中测试UI。

原始封面

爬虫对抗

Wed, 13 Dec 2017 02:52:34 +0800

why

知己知彼，百战不殆。

爬虫往往会爬取其他服务的一些核心资源，这些资源是服务提供商重点保护的资产，所以很多网站都会启用一些反爬虫策略。

这里我们简单分析一下反爬虫的常用手段。

监控后台日志和流量模式; 如果发现异常活动，则限制访问

通过日志是可以看出一些异常访问的，比如例如来自同一个IP地址的许多类似的请求操作。我们可以通过一些措施来限制这些访问，从而达到保护己方资源的效果，具体措施如下

访问速率限制
检测异常活动
不要只是通过IP地址监控和限制访问速率 —— 也可以使用其他指标，比如表单提交的速度，或者是user-agent
使用验证码替代临时阻止访问的方案

反爬建议:可以使用ip池，降低访问频率或浏览器自动化工具爬虫来进行对抗

要求注册和登录

如果你要求客户端创建帐户和登录，那么你可以准确的跟踪用户和爬虫的操作，另外也可以适当增加爬虫实现的难度。不过需不需要注册和登录最终还要看产品的需求，以产品需求为准。

为了避免自动化创建许多帐户的脚本，你应该做以下这些事情:

注册时需要一个电子邮件地址，并且用户必须打开通过你所发送的链接来验证该电子邮件地址才能激活该帐户。每个电子邮件地址只允许一个帐户。
需要在注册/帐户创建期间显示验证码，以防止自动化脚本创建帐户

反爬建议:爬虫可以模拟登录，另外降低访问频率，以免暴露真实意图

阻止来自云托管主机和爬虫服务的IP地址的访问

有时，爬虫会从网络托管服务（如Amazon Web Services或Google App Engine）或VPSes运行。限制（或显示验证码）来源于此类云主机服务使用的IP地址请求访问你的网站。你还可以阻止从爬虫服务使用的IP地址的访问。

同样，你还可以限制代理或VPN提供商使用的IP地址的访问，因为爬虫可能会使用此类代理服务器来避免单个IP发出许多请求。

反爬建议:使用代理和ip池

如果你要采取阻止访问的做法，请将你的错误消息进行调整

如果你采取了阻止/限制访问的手段，那么你应该确保不要告诉爬虫导致阻塞的实际原因，从而给爬虫制作者如何修复爬虫的线索。所以用文本显示错误页面可能是一个坏主意：

你的IP地址请求过于频繁，请稍后再试。
错误，User Agent不存在，非法访问！

相反，显示一个友好的错误消息，不要告诉爬虫是什么原因造成不能正常访问的。

抱歉，网站出了一些问题。如果问题仍然存在，你可以联系helpdesk@example.com。

这也是真正对用户友好的一种显示内容。你还应该考虑在后续的请求中不要直接显示验证码，以防真实用户看到这个错误消息，导致你阻止了合法用户的访问行为。

反爬建议:使用浏览器自动化工具，伪装成真实的用户

如果你的网站被爬虫访问，请使用验证码

验证码是双刃剑，可以非常有效的组织爬虫，但也会对真正的用户产生负面影响。

如果需要使用验证码，那么请

不要自己实现验证码，应该使用像Google的reCaptcha这样的东西：这比自己实现一个验证码要容易得多，它比一些模糊和扭曲的文本解决方案对用户来说更友好，而且比起自己实现验证码，它能更好的解决问题
不要在HTML标记中包含验证码的解决方案：实际上我已经看到一个网站在页面中嵌入了验证码的解决方案（虽然隐藏的很好）。但是不要这样做。还是推荐使用像reCaptcha这样的服务，如果你正确使用它，就不会出现问题。
验证码是可以批量验证的：在网上有一些低报酬的人工打码服务可以批量解决验证码的验证服务。所以，我在这里还是推荐使用reCaptcha，因为它具有很好的自我保护作用。这种服务不太可能被用于人工打码，除非你的数据真的很有价值。

反爬建议:使用人肉打码服务

将你的文本内容转成图片

你可以在服务器端将文本转换成图像然后在客户端显示，这种方法可以阻碍简单的爬虫提取文本。

记得当年起点的付费阅读的内容就全部是图片形式的。

然而，这对于屏幕阅读器，搜索引擎，性能以及其他的一些事情都是不利的。在某些方面（比如无障碍操作，例如美国残疾人法案）也可能是非法的，并且也很容易被一些OCR技术绕过，所以最好还是不要这样做。

反爬建议:使用OCR图片识别技术

不要公开你的完整数据集

如果可行的话，请不要为脚本或爬虫机器人提供所有数据集的方法。例如：你有一个新闻网站，有很多单独的文章。你可以通过现场搜索来搜索这些文章，并且如果你没有列出任何网站上的所有文章及其URL，那么这些文章将只能通过使用搜索来访问特征。这意味着一个想要从你的网站上获得所有文章的脚本将不得不搜索可能出现在你的文章中的所有可能的短语，才能找到文章的全部内容，这对于爬虫来说是很耗时的，而且效率低的可怕，所以爬虫一般都会放弃爬取数据。

如果是以下这些情况，那么这种方法将变得无效：

爬虫机器人或脚本并不想或需要完整的数据集。
你的文章的URL是一个看起来像 example.com/article.php?articleId=12345这种（和类似的东西）的格式，这将允许爬虫可以简单地迭代所有articleId的文章，并请求所有的文章内容。
还有其他方式可以最终找到所有的文章，比如通过编写一个脚本来跟踪其他文章的内容中的链接。
搜索“&”或“”的东西可以显示几乎所有的东西，这是一些需要注意的事情。（你只能返回前10或20个结果来避免这种情况）。
你需要搜索引擎来查找你的内容。

反爬建议:遍历数字型id基本可以拿到所有内容

参考资料

文本大部分参考了Web网页爬虫对抗指南 Part.1这篇文章，在这里附上原始链接，并对原作者和译者表示衷心的感谢。

原始封面

（六） mockito 常用方法

Sat, 25 Nov 2017 12:40:11 +0800

doReturn()、doThrow()、doAnswer()、doNothing()、doCallRealMethod()系列方法的运用

通过when(Object)为无返回值的函数打桩有不同的方法,因为编译器不喜欢void函数在括号内…

使用doThrow(Throwable) 替换stubVoid(Object)来为void函数打桩是为了与doAnswer()等函数族保持一致性。

当你想为void函数打桩时使用含有一个exception 参数的doAnswer() :

import org.junit.Test;
import java.util.LinkedList;
import static org.mockito.Mockito.*;


public class MockitoDemo {

 @Test(expected = RuntimeException.class)
 public void when_doThrow() throws RuntimeException {

 LinkedList mockedList = mock(LinkedList.class);
 doThrow(new RuntimeException()).when(mockedList).clear();

 //following throws RuntimeException:
 // 下面的代码会抛出异常
 mockedList.clear();
 }
}

当你调用doThrow(), doAnswer(), doNothing(), doReturn() 和 doCallRealMethod() 这些函数时可以在适当的位置调用when()函数，例如下面这些功能时这是必须的:

测试void函数
在受监控的对象上测试函数
不知一次的测试为同一个函数，在测试过程中改变mock对象的行为。

但是在调用when()函数时你可以选择是否调用这些上述这些函数。

原始封面

（六）TestNG 用例分组

Sat, 25 Nov 2017 12:35:11 +0800

有时候我们的测试用例并不想以测试包、类和用例为单位去运行。测试用例可以有多个纬度去标识。

例如，可以根据用例的重要程度划分：

重要程度：低——>中——>高

或者，根据用例的类型划分：

类型：正常——>异常

TestNG 允许我们给测试用例贴标签。我们可以根据这些标签有选择地的跳过或执行这些用例。

实例

import org.testng.annotations.Test;

import static org.testng.AssertJUnit.assertEquals;


@Test(groups = {"功能测试"})
public class TagTest {

 @Test(groups={"高", "正常"})
 public void testCase1(){
 assertEquals(2+2, 4);
 }

 @Test(groups = {"高", "正常"})
 public void testCase2(){
 assertEquals(5-3, 2);
 }
 @Test(groups = {"中", "正常"})
 public void testCase3(){
 assertEquals(2/1, 2);
 }

 @Test(groups = {"低", "异常"})
 public void testCase4(){
 assertEquals(2/0, 1);
 }

}

接下来配置 testng.xml ，根据标签筛选要运行的测试用例。

（六） pom.xml 配置文件

Sat, 25 Nov 2017 12:30:11 +0800

用 Maven 来管理 Java 项目的第三方库，最主要是通过 pom.xml 文件，这一小节将解释该文件的使用。

pom.xml 文件

以（四）通过 mvn 命令创建 Maven 项目创建的项目为例。打开项目根目录下的 pom.xml 文件。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>com.myapp.pro</groupId>
 <artifactId>myapp</artifactId>
 <packaging>jar</packaging>
 <version>1.0-SNAPSHOT</version>

 <name>myapp</name>
 <url>http://maven.apache.org</url>

 <dependencies>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>3.8.1</version>
 <scope>test</scope>
 </dependency>

 </dependencies>

</project>

* project：pom.xml文件中的顶层元素；

* modelVersion：指明POM使用的对象模型的版本。这个值很少改动。

* groupId：指明创建项目的组织或者小组的唯一标识。GroupId是项目的关键标识，典型的，此标识以组织的完全限定名来定义。比如，org.apache.maven.plugins是所有Maven插件项目指定的groupId。

* artifactId：指明此项目产生的主要产品的基本名称。项目的主要产品通常为一个JAR文件。第二，象源代码包通常使用artifactId作为最后名称的一部分。典型的产品名称使用这个格式： - . (比如：myapp-1.0.jar)。

* version：项目产品的版本号。Maven帮助你管理版本，可以经常看到SNAPSHOT这个版本，表明项目处于开发阶段。

* name：项目的显示名称，通常用于maven产生的文档中。

* url：指定项目站点，通常用于maven产生的文档中。

* description：描述此项目，通常用于maven产生的文档中。

管理第三方库

对于一个第三方库的添加，下面的几个参数是我们需要关注的。

<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>

，它主要管理依赖的部署。目前可以使用5个值：

compile，缺省值，适用于所有阶段，会随着项目一起发布。
provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。
system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。

通过查看pom.xml中Junit的配置，显然版本有些旧了，我们去下载最新的Junit4，但我们又不知道Maven中的具体的版本怎么办呢？我们可以到 Maven 的中央仓库去查询。

requests如何构造复杂的post请求?

Wed, 22 Nov 2017 03:23:57 +0800

默认情况下，在post方法中使用 data 关键字参数，Requests的行为会表现的像是在发送一个html表单，比如

>>> payload = {'key1': 'value1', 'key2': 'value2'}

>>> r = requests.post("http://httpbin.org/post", data=payload)
>>> print(r.text)
{
 ...
 "form": {
 "key2": "value2",
 "key1": "value1"
 },
 ...
}

如果需要为多个元素使用同一key的话，可以在data中传入元组，比如

>>> payload = (('key1', 'value1'), ('key1', 'value2'))
>>> r = requests.post('http://httpbin.org/post', data=payload)
>>> print(r.text)
{
 ...
 "form": {
 "key1": [
 "value1",
 "value2"
 ]
 },
 ...
}

如果 data 中传的是string而不是dict的话，那么字符串将会被直接发送出去

>>> import json

>>> url = 'https://api.github.com/some/endpoint'
>>> payload = {'some': 'data'}

>>> r = requests.post(url, data=json.dumps(payload))

因为现在很多api接受json字符串格式的post data，Requests为这种方式提供了更简单的写法

（六）JUnit 用例执行顺序

Mon, 13 Nov 2017 12:40:11 +0800

在运行测试的过程中，有时候需要控制用例的执行顺序。

@FixMethodOrder

JUnit 通过 @FixMethodOrder 注解来控制测试方法的执行顺序的。@FixMethodOrder 注解的参数是 org.junit.runners.MethodSorters 对象,在枚举类 org.junit.runners.MethodSorters 中定义了如下三种顺序类型：

MethodSorters.JVM

Leaves the test methods in the order returned by the JVM. Note that the order from the JVM may vary from run to run (按照JVM得到的方法顺序，也就是代码中定义的方法顺序)

MethodSorters.DEFAULT(默认的顺序)

Sorts the test methods in a deterministic, but not predictable, order() (以确定但不可预期的顺序执行)

MethodSorters.NAME_ASCENDING

Sorts the test methods by the method name, in lexicographic order, with Method.toString() used as a tiebreaker (按方法名字母顺序执行)

6. 命令行接口

Sun, 05 Nov 2017 06:23:31 +0800

背景

unittest支持命令行接口，我们可以在命令行里指定运行具体的测试用例。

实例

在test_password_1.py中定义了PasswordTeseCase用例，我们可以从命令行中指定只运行该用例。

$ python -m unittest test_password_1.PasswordTeseCase
set up
.set up
F
======================================================================
FAIL: test_week_password (test_password_1.PasswordTeseCase)
----------------------------------------------------------------------
Traceback (most recent call last):
 File "/Users/easonhan/code/testclass.net/src/pyunit/test_password_1.py", line 21, in test_week_password
 self.assertTrue(passwd != 'password123', msg)
AssertionError: False is not true : user tom has a weak password

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

还可以使用-v参数来获得更详细的输出

$ python -m unittest test_password_1.PasswordTeseCase -v
test_dummy (test_password_1.PasswordTeseCase) ... set up
ok
test_week_password (test_password_1.PasswordTeseCase) ... set up
FAIL

======================================================================
FAIL: test_week_password (test_password_1.PasswordTeseCase)
----------------------------------------------------------------------
Traceback (most recent call last):
 File "/Users/easonhan/code/testclass.net/src/pyunit/test_password_1.py", line 21, in test_week_password
 self.assertTrue(passwd != 'password123', msg)
AssertionError: False is not true : user tom has a weak password

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

也可以在命令行中一次指定多个测试用例类，具体的大家可以自己尝试一下。

6. 转义序列和多行文本

Thu, 02 Nov 2017 08:17:22 +0800

转义序列

python提供了一种方式让我们可以输入一些不太好通过键盘输入的字符，比如换行符缩进符之类的。这种特殊的字符组合我们可以称之为转义序列(escape sequences)，详情可以参考官方文档。

我们经常使用的有

\n: 换行
\t: tab，可以当成是缩进
\: 反斜杠
': 单引号，可以在单引号字符串中打印出单引号
": 双引号，可以在双引号字符串中打印出双引号

多行文本

python中3个引号开头的字符串中可以包含多行文本，比如


my_str="""
this is the first line
this is the second line
this is the last line
"""

背景

这一节里，我们强化一下转义序列和多行文本的使用和写法。

代码实现

新建名为print_test_case.py，内容如下


test_scenario = "登录场景\n"

test_case_name = "\t正常登录: \n"

# two tabs
tt = "\t\t"

test_step = f"{tt}1.打开chrome浏览器\n{tt}2.输入www.itest.info\n{tt}3.在登录表单中输入用户名:example，密码:example\n{tt}4.登记登录按钮\n"

test_assert = f"{tt}应该跳转到www.itest.info/login_success页面，并出现\"登录成功\"的提示"

print(test_scenario + test_case_name + test_step + test_assert)

test_login_failed = """
 密码错误:
 1.打开chrome浏览器
 2.输入www.itest.info
 3.在登录表单中输入用户名:example，密码:incorrect
 4.登记登录按钮
 页面不发生跳转，并出现\"登录失败\"的提示
"""
print(test_login_failed)

运行

在命令行中使用下面的命令去执行代码

6.Parametrize Fixture

Sun, 29 Oct 2017 07:22:42 +0800

背景

@pytest.mark.parametrize 装饰器可以让我们每次参数化fixture的时候传入多个项目。回忆上一节，我们参数化的时候只能传入传入1个字符串或者是其他的数据对象，parametrize每次多个参数，更加灵活。

例子

import pytest
@pytest.mark.parametrize("test_input,expected", [
 ("3+5", 8),
 ("2+4", 6),
 ("6*9", 42),
])
def test_eval(test_input, expected):
 assert eval(test_input) == expected

test_eval方法中传入了2个参数，就如同@pytest.mark.parametrize装饰器中定义的那样，因此简单理解，我们可以把parametrize装饰器想象成是数据表格，有表头(test_input,expected)以及具体的数据。

运行结果

$ pytest
======= test session starts ========
platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
rootdir: $REGENDOC_TMPDIR, inifile:
collected 3 items

test_expectation.py ..F

======= FAILURES ========
_______ test_eval[6*9-42] ________

test_input = '6*9', expected = 42

 @pytest.mark.parametrize("test_input,expected", [
 ("3+5", 8),
 ("2+4", 6),
 ("6*9", 42),
 ])
 def test_eval(test_input, expected):
> assert eval(test_input) == expected
E AssertionError: assert 54 == 42
E + where 54 = eval('6*9')

test_expectation.py:8: AssertionError
======= 1 failed, 2 passed in 0.12 seconds ========

原始封面

6. Logical Containers

Tue, 24 Oct 2017 06:55:26 +0800

逻辑容器适用于这样的场景：页面上有一些元素确实存在于容器中，但这些元素都有可以唯一能够定位的属性，比如id等，而我们为了代码的可读性，往往希望将这些元素放在某个容器中。

比如页面上的菜单元素，每个子菜单都有id属性，不过为了代码能够更好的被他人理解，我们希望将子菜单放到菜单容器里。

逻辑容器和普通容器的区别：

普通容器需要继承自WebElement，而逻辑容器不需要
定义逻辑容器时Find方法不需要by和value参数

from selenium.webdriver.common.by import By
from webium import Find, BasePage


class Nav(object):
 class_info = Find(by=By.CSS_SELECTOR, value='a[href*="/newclass"]')
 faq = Find(by=By.CSS_SELECTOR, value='a[href*="/faq"]')


class ItestPage(BasePage):
 # here we are just grouping Header elements together without any influence on actual search
 nav = Find(Nav)

 def __init__(self):
 super(StructuredPage, self).__init__(url='http://itest.info')


if __name__ == '__main__':
 page = ItestPage()
 page.open()
 print(page.menu.class_info.text)
 print(page.menu.faq.text)

原始封面

收藏清单: python测试数据生成及代码扫描最全资源列表

Fri, 20 Oct 2017 08:22:28 +0800

Test Data manipulation 测试数据的操作和处理

faker - 生成假数据的python库
fake2db - 创建假数据库
ForgeryPy - 使用起来很简单的假数据生成库.
radar - 随机生成时间
robotframework-faker - faker的Robot Framework封装
hypothesis - Library for property based testing in Python, based on the Haskell library Quickcheck.
factory_boy - factory_girl的python版本
fauxfactory - 随机数据生成器

Code analysis 代码扫描及分析

pysonar2 - 类型推断
coverage - 覆盖率
pycallgraph - 流程可视化
Flake8 - The modular source code checker: pep8, pyflakes and co.
pylama - Python and JavaScript的代码审查工具
Pylint - 源代码分析器
hacking - OpenStack Hacking Style Checks (flake8 plugins).
prospector - 代码分析工具，可以输出错误信息，潜在问题，不规范的代码以及代码复杂度

原始封面

（六）实战：构建 GitHub 项目(上)

Mon, 16 Oct 2017 11:55:11 +0800

Jenkins 不是一个对开发零基础的人去用的工具。不管你要构建什么样的项目，首先要有这么个项目存在，而且还要知道如何运行该项目。

快速创建 GitHub 项目

如果你想快速的使用 GitHub 来维护你的自动化测试项目，请阅读该教程。

Jenkins 配置 Git

首先，登录 Jenkins ，在首页找到 “系统管理 -> Global Tool Configuration -> Git ”

Path to Git executable ：设置 Git 执行文件的位置。从你Git的安装目录中查看 “git.exe” 可执行文件的位置。

设置完成后点击 “Save” 保存设置。

原始封面

（六）Locust 分布式运行

Mon, 16 Oct 2017 10:00:11 +0800

参考：官方文档

分布式运行Locust

一旦单台机器不够模拟足够多的用户时，Locust支持运行在多台机器中进行压力测试。

为了实现这个，你应该在 master 模式中使用--master标记来启用一个 Locust 实例。这个实例将会运行你启动测试的 Locust 交互网站并查看实时统计数据。master 节点的机器自身不会模拟任何用户。相反，你必须使用 --slave 标记启动一台到多台 Locustslave 机器节点，与标记 --master-host 一起使用(指出master机器的IP/hostname)。

常用的做法是在一台独立的机器中运行master，在slave机器中每个处理器内核运行一个slave实例。

注意：master 和每一台 slave 机器，在运行分布式测试时都必须要有 locust 的测试文件。

示例

在 master 模式下启动 Locust:

locust -f my_loucstfile.py --master

在每个 slave 中执行(192.168.0.14 替换为你 msater 的IP):

locust -f my_locustfile.py --slave --master-host=192.168.0.14

参数说明

参数

–master

设置 Locust 为 master 模式。网页交互会在这台节点机器中运行。

–slave

设置 Locust 为 slave 模式。

–master-host=X.X.X.X

可选项，与 --slave 一起结合使用，用于设置 master 模式下的 master 机器的IP/hostname(默认设置为127.0.0.1)

–master-port=5557

可选项，与 --slave 一起结合使用，用于设置 master 模式下的 master 机器中 Locust 的端口(默认为5557)。注意，locust 将会使用这个指定的端口号，同时指定端口+1的号也会被占用。因此，5557 会被使用，Locust将会使用 5557 和 5558。

06. 安装环境总结（新用户必看）

Mon, 16 Oct 2017 07:00:11 +0800

安装总结

硬件建议

从上一讲的安装教程来看，IntelliJ IDEA 对硬件的要求看上去不是很高。可是实际在开发中其实并不是这样的，特别是开发 Java Web 的项目的计算机，2G 内存是基本不够用的。

我们现在来假设一种国内常见的开发环境：

有一个在开发的 Java Web 项目，它使用的框架为主流的：Struts + Spring + Hibernate，使用这三个框架的过程中，我们要引入大量的框架 jar 包，在我们的 Web 容器启动时，这些框架架包就要占用大量的内存，而且 IntelliJ IDEA 本身功能繁多，占用的内存也不算低，再加上我们这里还没计算计算机上的其他软件应用。所以基本上 2G 内存的计算机只适合写小程序、小项目或是开发静态页面。

我个人建议，如果你是开发 Java Web 项目最好的方案是 8G 内存或是以上，硬盘能再用上固态是最好的，因为 IntelliJ IDEA 有大量的缓存、索引文件，把 IntelliJ IDEA 的缓存、索引文件放在固态上，IntelliJ IDEA 流畅度也会加快很多。

如果你正在使用 Eclipse / MyEclipse，想通过 IntelliJ IDEA 来解决计算机的卡、慢等问题，我这里可以直接明白地告诉你：这基本上是不可能的，本质上你应该对自己的硬件设备进行升级。

原始封面

（六）soapUI创建REST项目

Wed, 20 Sep 2017 21:00:11 +0800

创建 REST 项目

打开 soapUI 工具。创建一个 REST 项目。

在窗口左侧导航栏，右键 Projects –> New REST Project。

添加REST接口

以本地查询发布会接口为例。

URI：http://127.0.0.1:8000/events/ 为接口URI。

点击 OK 按钮，创建项目完成。

依次展开：REST Project 1–>Events[/events/]–>Events–>Request 1 , 为 REST 接口窗口。

点击 Request 1 窗口中左上角的绿色运行按钮，右则窗口显示接口查询结果。

设置接口URI

如果想查询具体的某一条发布会信息，可以在 Resource 输入框中指定发布会 id，如下图。

appium新手入门（6）—— appium-desktop

Thu, 07 Sep 2017 10:24:12 +0800

什么是 Appium-desktop？

项目地址：https://github.com/appium/appium-desktop

项目描述：

Appium Server and Inspector in Desktop GUIs for Mac, Windows, and Linux。

Appium 移动测试中有个很重新的组件 Appium-Server，它主要用来监听我们的移动设备（真机或模拟器），然将不同编程语言编写的 appium 测试脚本进行解析，然后，驱动移动设备来运行测试。

但Appium-Server有一两年没有更新了。Windows版在 2015 年底止步于的 AppiumForWindows_1_4_16_1.zip

于是，新的工具 Appium-desktop 来了！它来继续 Appium-Server的使命，当然， Appium-Server当前仍然是可用的。

下载与安装

appium-desktop 下载地址：这里

根据自己的平台选择相关的包进行下载。本文以 Windows 为例，所以选择 appium-desktop-Setup-1.2.4.exe 文件进行下载。

安装过程太简单了，双击 exe 文件，然后，等待安装完就好了，中间都不需要你设置任何选项。所以，这里就不贴图了。

启动运行

安装完成桌面会生成一个紫色的 appium 图标，双击打开。

默认显示监控的 host 和 port ，这和 Appium-Server中是一致的。点击 “Start Server V 1.7.1” 按钮启动服务。

6.unittest框架

Fri, 25 Aug 2017 04:41:43 +0800

在我们真正的编写测试用例之前，我们需要了解一下测试框架。

unittest是python自带的单元测试框架，尽管其主要是为单元测试服务的，但我们也可以用它来做接口的自动化测试。

unittest框架为我们编写用例提供了如下的能力

定义用例的能力。unittest框架有一套固有套路，可以让我们定义测试用例时更加简单和统一
断言的能力。unittest框架提供了一系列的断言
各种执行策略。通过test suit或者扩展的方式，我们可以自定义用例执行的策略

简单的例子

import unittest

class StringTestCase(unittest.TestCase):
 def setUp(self):
 # Arrange
 self.test_string = "This is a string"

 def testUpper(self):
 # Act and Assert
 self.assertEqual("THIS IS A STRING", self.test_string.upper())

if __name__ == '__main__':
 unittest.main()

剖析

import unittest

导入unittest库，不导入就没办法使用，好比手机如果要使用某个app就必须先安装该app一样，是套路，记住就好。

class StringTestCase(unittest.TestCase):

定义测试类，初学者看到这一行就害怕，其实大可不必。这还是套路，测试类的名字你可以随意取，当然了首字母最好大写，这样更符合规范一些。所有的测试类都必须直接或间接的继承自unittest.TestCase类。总之，这还是套路，记住就好。

def setUp(self):
 # Arrange
 self.test_string = "This is a string"

继续套路。setUp(self)方法是一个钩子方法，在每个测试用例执行之前都会执行一次，是做数据初始化的好地方。

在上面的例子里，我们为每一个测试方法都定义了被测对象，self.test_string

def testUpper(self):
 # Act and Assert
 self.assertEqual("THIS IS A STRING", self.test_string.upper())

套路继续。这里定义了一个名为testUpper的测试方法，这个方法就是一个测试用例。

注意，只有方法名以test开头的方法才是测试用例

self.assertEqual是一个断言方法，作用是如果第一个参数跟第二个参数相等，那么用例通过，否则用例失败，并在测试报告中打印出错误原因。上面的例子里，我们判断self.test_string.upper()方法会将"This is a string"字符串转换成"THIS IS A STRING"

if __name__ == '__main__':
 unittest.main()

最后依然是套路，上面的代码表示，如果直接执行该python文件的话，就运行所有的测试类里的测试用例，也就是运行所有的以test开头的方法。

总结

使用unittest的话需要记住下面的几点

导入unittest
定义继承自unittest.TestCase的测试类
定义以test开头的测试方法，这个方法就是测试用例，你可以在一个类里定义n个测试用例
断言
unittest.main()是执行测试用例最简单的方式

原始封面

JMeter官方文档：6. 建立数据库测试计划

Thu, 24 Aug 2017 11:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

6. 建立数据库测试计划（Building a Database Test Plan）

在本节中，您将学习如何创建测试数据库服务器一个简单的测试计划。您将创建五十个用户向数据库服务器发送2个SQL请求。并且，使这些用户运行测试100次。所以，请求的总数是（50个用户）x（2个请求）x（重复100次）= 10'000个JDBC请求。要构建测试计划，您将使用以下元素：线程组， JDBC请求，摘要报告。

此示例使用MySQL数据库驱动程序。要使用此驱动程序，它包含.jar文件（例如mysql-connector-java-XXX-bin.jar）必须复制到JMeter __./lib__ 目录（有关详细信息，请参阅[JMeter的Classpath](http://jmeter.apache.org/usermanual/get-started.html#classpath)）。

6.1添加用户（Adding Users）

您要对每个JMeter测试计划执行的第一步是添加一个线程组元件。线程组告诉JMeter您想要模拟的用户数量，用户应发送请求的频率以及应发送的请求数量。继续添加线程组元件，首先选择测试计划，单击鼠标右键获取添加菜单，然后选择添加 → 线程组。

您现在应该看到“测试计划”下的“线程组”元件。如果没有看到该元件，则通过单击“测试计划”元件,从而展开“线程组”元件。

接下来，您需要修改默认属性。如果尚未选择它，请选择树中的线程组元件。您现在应该在JMeter窗口的右侧部分看到线程组控制面板（参见下面的图6.1）

图6.1 具有默认值的线程组

首先为我们的线程组提供更具描述性的名称。在名称字段中，输入：JDBC users。

您将需要有效的数据库，数据库表和对该表的用户级访问。在这里显示的例子中，数据库是“guest_test”，表名是“vm_instance”。

接下来，将用户数增加到50个。

在下一个字段中，“Ramp-Up Period” 的值为10秒。此属性告诉JMeter启动每个用户需要多长时间。例如，如果您输入10秒的Ramp-Up Period时间，JMeter将在10秒之后完成所有用户的启动。所以，如果我们有50个用户和10秒的 Ramp-Up Period，则起始用户之间的延迟将是200毫秒（10秒/ 50个用户=每秒0.2个用户）。如果将值设置为0，那么JMeter将立即启动所有用户。

最后，在循环计数字段中输入值100。此属性告诉JMeter重复测试多少次。要让JMeter循环运行测试计划，请选中“永远”复选框。

在大多数应用程序中，您在控制面板中进行的更改必须点击确定按钮。但是，在JMeter中，控制面板会在您进行更改时自动保存您的更改。如果更改元素了名称，在离开控制面板后（例如，当选择另一个树形元件）时，系统将自动保存您的更改。

有关完成的JDBC用户线程组，请参见图6.2。

图6.2 JDBC用户线程组

appium简明教程（6）——启动appium及android模拟器

Tue, 15 Aug 2017 07:33:41 +0800

一般情况下，我们都从命令行启动appium。

windows下，dos命令窗口输入

appium

如果该命令报错，那么请重装appium

npm install -g appium

如果安装出错，请使用淘宝源。

淘宝源地址

然后请打开android的模拟器，如果没有请新建一个虚拟设备。请自行解除设备锁定（手动把屏幕解锁了），以防万一。

下面的代码以启动android原生的计算器程序为例

ruby篇

require 'appium_lib'

caps = { caps: { platformName: 'Android', appActivity: '.Calculator', appPackage: 'com.android.calculator2' },
 appium_lib: { sauce_username: nil, sauce_access_key: nil } }
driver = Appium::Driver.new(caps).start_driver

讨论：可以看出ruby lib里面的Appium::Driver类实际上就是原生的webdriver类的子类，当然了，由于ruby语法灵活，也可以使用monkey patch来实现类似功能。

python篇

from appium import webdriver
desired_caps = {}
desired_caps['platformName'] = 'Android'
desired_caps['platformVersion'] = '4.2'
desired_caps['deviceName'] = 'Android Emulator'
desired_caps['appPackage'] = 'com.android.calculator2'
desired_caps['appActivity'] = '.Calculator'

driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)

讨论：webdriver.Remote实际上就是原生webdriver的子类，另外Remote()构造函数的第一个参数中需要显示指定appium server监听的端口

java篇

新建java项目时候，请注意将selenium-webdriver以及appium client的jar包导入

import io.appium.java_client.AppiumDriver;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;

DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(CapabilityType.BROWSER_NAME, "");//这句不是必须的
capabilities.setCapability("deviceName","Android Emulator");
capabilities.setCapability("platformVersion", "4.4");
capabilities.setCapability("platformName","Android");
capabilities.setCapability("appPackage", "com.android.calculator2");
capabilities.setCapability("appActivity", ".Calculator");
AppiumDriver driver = new AppiumDriver(new URL("http://127.0.0.1:4723/wd/hub"), capabilities);

讨论:AppiumDrvier是原生webdriver的子类。

性能测试流程（一）——问清性能需求

Fri, 11 Aug 2017 08:59:11 +0800

假如你一名新进公司的测试小菜鸟，在一次的早会中，领导突然分配给你了一个性能测试任务。我想此时的你是一脸的大写？？，怎么办？怎么办？这里会提供一个通用的测试思路，照着这个思路做，你就会顺利的完成性能测试。

问清性能测试需求

首先，要问本次性能测试的需求是什么，或者性能测试的目的是什么？我把性能测试按目的分以下几种。

1）新系统能力验证

比如，你们刚好开发了一个新系统，在上线前需要验证系统性能。这种情况比较简单；你可以有更多的自由选择测试环境、压力点和测试工具；测试策略上也比较灵活。并且如果性能测试结果没有明显的短板，也不需要进行调优。

2）客户有明确要求

这是一个好的结果，这说明客户对性能测试有一定的了解，知道他们需要的系统要达到一个什么样的标准。如：系统要求同时满足100用户登陆，平均每个用户登陆时间不能超过5秒。这个需求很明确，当然也不排除一些不懂装懂的用户，提一些不现实的要求。

不管怎么说，用户提要求了，这个比较容易，你可以对现系统做一次性能测试，至于，是通过优化系统还是增加硬件设备才能达到要求。就不是测试考虑的问题了。

3）找出系统性能瓶颈

这个需求的目的就很明确了，目的就是找出系统的性能瓶颈，进行调优或硬件扩容，所以性能测试的重点在系统的架构分析和业务分析上面。

4）稳定性验证（强度测试）

稳定性是系统的一个重要指标，因为系统一旦上线，就有可能会长期处在用户的访问状态，可能以前没发现的一些问题就会暴漏出来。比较典型的就是内存溢出，这种需求在测试策略上就要考虑性能测试的运行时长。

注意： 当拿到需求时一定要问测试的目的，一方面会显得你很专业；另一方面，我们通过测试目的可以知道后续性能测试工作的重点在哪儿？最主要的是，还可以揣摩出领导对这次测试的重视程度。^_^!

原始封面

（六）通过className去定位页面上的元素

Tue, 08 Aug 2017 02:28:40 +0800

为什么是className

用className定位实际上是通过元素的html属性class定位，由于最早的webdriver client版本是使用java实现的，java中class是一个保留字，class不给用，所以就使用了className来替代。

复合的class属性

selenium不支持复合的class属性。比如class="col-md-1 col-sm-2"，我们只能通过col-md-1或者是col-sm-2来定位，不能同时使用这2个class进行定位。

目的

熟悉selenium webdriver 定位方式
学会通过class属性去定位元素

练习对象

我们使用html5-test-page作为我们的练习对象。

将html代码拷贝一份并保存到本地，文件名为index.html。

场景

我们将使用className定位下面html代码所示的输入框，并输入一些内容

<p>
 <label for="input__text3" class="error">Error</label>
 <input id="input__text3" class="is-error" type="text" placeholder="Text Input">
</p>
<p>
 <label for="input__text4" class="valid">Valid</label>
 <input id="input__text4" class="is-valid" type="text" placeholder="Text Input">
</p>

代码

var path = require('path');
var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var testFile = "file://" + path.join(__dirname, "index.html")

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get(testFile)

dr.findElement(By.className('is-error')).sendKeys('should be error');
dr.findElement(By.className('is-valid')).sendKeys('should be valid');

运行结果

如下图所示

原始封面

软件测试综合笔试题（1）

Wed, 26 Jul 2017 09:44:38 +0800

1、__HTTP协议有什么特点？有哪几类状态码，分别表示什么意思？__

特点:

无连接：限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。
媒体独立：只要客户端和服务器知道如何处理的数据内容，任何类型的数据都可以通过HTTP发送。
无状态：无状态是指协议对于事务处理没有记忆能力。

状态码分类和含义:

1xx：指示信息：表示请求已接收，继续处理。
2xx：成功：表示请求已被成功接收、理解、接受。
3xx：重定向：要完成请求必须进行更进一步的操作。
4xx：客户端错误：请求有语法错误或请求无法实现。
5xx：服务器端错误：服务器未能实现合法的请求。

2、__列举出10个你常用的shell命令，并说明其作用。__

这个只要你平时多用Linux系统，写10个命令问题不大。参考我的Linux那些事儿

3、__你认为测试工程师应该掌握哪些技术，其中有哪些是你已经掌握的？__

根据自己所掌握的测试技术自由发挥，参考：

4、__简述cookies和session是怎么工作的？__

Cookie机制： 正统的Cookie分发是通过扩展HTTP协议来实现的，服务器通过在 HTTP 的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的Cookie。然而纯粹的客户端脚本如JavaScript 或者 VBScript也可以生成 Cookie。而Cookie的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的Cookie，如果某个Cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。

Session 机制： Session 机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。

5、__你认为WEB测试和APP测试有什么不同？__

工作平台不同：Web主要运行在浏览器上面，APP的运行基于移动操作系统。
界面开发技术不同：Web主要通过前端技术（HTML/JS/CSS）来设计页面，APP(Android)主要通过布局文件来设计界面。
其它：你自行补充。。。

6、__用你熟悉的一种编程语言，写出计算以下结果的代码。1+2+3+…+100=？__

以下通过Python语言实现：

j = 0

for i in range(1,101):
 j =j + i

print("计算结果为：%d" %j)

7、__表：UC__

字段	字段名称	类型
FID	用户ID	int
NAME	用户名称	Varchar
EMAIL	用户邮箱	Varchar
FBAL	用户金额	decimal(20,2)

写出以下功能的sql语句：

（六）软件测试分工

Fri, 21 Jul 2017 12:59:11 +0800

按照本文的主题还是来谈谈软件测试人员的分工吧！主要来谈传统软件测试过程中的测试分工。

集体测试

也许专业测试里讲这种方式，很可能不叫“集体测试”。因为我根据的自己的理解起了大概符合意思的名词叫集体测试“集体测试”。

这种测试模式就是，公司里所有的测试人员抱成一团儿，来一个项目，所有测试人员就集中测试一个项目。

先说这种分工方式的优点：

2、人多的另一个好处是测试项目能可以在更快的时间内发现更多的缺陷。总结一下就是更短时间内发现更多的问题。

再来说说这种方式的缺点：

1、一个人员一张嘴，人力成本很高（人员工资，人员平均时间投入，测试机等硬件资源投入）。

2、当同时需要测试多个项目中时，不好意思，按顺序来，请在后面排好队。（并发能力不足）

3、工作重复，同样一个缺陷，很可能同时被所有测试员发现，或者叫重复率很高。

5、发现了漏测现象是整个测试团队的责任。（这也不是明确的缺点，要看团队的氛围是积极的还是消极的。）

好吧！集体测试缺点太多，就像国家成立初期的“吃大锅饭”，肯定是阻碍发展的。那我们来看看几种分工方式。

#### 按测试内容分工 ---

内容分工方式的优点：

1、分工明确，每位人员都清楚自己的测试的内容重点。

2、责任到位，通过漏测的缺陷就可明确是谁的责任。

#### 按测试流程划分 ----

我们的项目测试流程一般需要，制定测试计划，编写测试用例，执行测试用例，输出测试报告等工作，我们可以根据流程中的各个阶段来进行划分。

不同的测试人员负责不同测试阶段的工作。

优点：

1、流程清晰，就像瀑布试项目开发流程，不同阶段的工作由不同的人员担任。

2、划分流程的每个阶段难易程度和所需要的技能。

编写测试计划人员需要对整个项目的工作时间、资源分配，测试内容，实施过程有整体的把控能力。

用例辨析人员，需要对项目需求，测试方法，测试点有深入的了解。

用例执行人员需要细心，使用缺陷系统，沟通，协助研发定位缺陷。

输出测试报告人员需要对项目的测试过程，缺陷数量，类型，分布。用例执行请况等进行统计。也可以由测试执行人员担任。

#### 按项目模块划分 ---- ![](http://img.testclass.net/module_test.png)

1、人员利用率高，为什么这么说呢? 不同的人员负责的功能不一样。工作就不会存在交叉与重复。

#### 按照测试类型分工 ----

（六）控制浏览器操作

Mon, 03 Jul 2017 07:37:11 +0800

### 控制浏览器窗口大小

有时候我们希望能以某种浏览器尺寸找开，访问的页面在这种尺寸下运行。例如可以将浏览器设置成移动端大小(480* 800)，然后访问移动站点，对其样式进行评估；WebDriver 提供了 manage().window().setSize()方法来设置浏览器的大小。

maximize() 设置浏览器最大化
setSize() 设置浏览器宽高

import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;


public class Browser {
 public static void main(String[] args) throws InterruptedException {

 WebDriver driver= new ChromeDriver();
 driver.get("https://www.baidu.cn");

 driver.manage().window().maximize();
 Thread.sleep(2000);

 driver.get("https://m.baidu.cn");
 driver.manage().window().setSize(new Dimension(480, 800));
 Thread.sleep(2000);

 driver.quit();
 }
}

在 PC 端执行自动化测试脚本大多的情况下是希望浏览器在全屏幕模式下执行，那么可以使用 maximize()方法使打开的浏览器全屏显示，其用法与 setSize()相同，但它不需要任何参数。

### 控制浏览器后退、前进

back() 模拟浏览器后退按钮

（六）鼠标事件

Sun, 25 Jun 2017 12:59:11 +0800

在 WebDriver 中，将这些关于鼠标操作的方法封装在 ActionChains 类提供。

ActionChains 类提供了鼠标操作的常用方法：

perform()：执行所有 ActionChains 中存储的行为；
context_click()：右击；
double_click()：双击；
drag_and_drop()：拖动；
move_to_element()：鼠标悬停。

### 鼠标悬停操作

from selenium import webdriver
# 引入 ActionChains 类
from selenium.webdriver.common.action_chains import ActionChains

driver = webdriver.Chrome()
driver.get("https://www.baidu.cn")

# 定位到要悬停的元素
above = driver.find_element_by_link_text("设置")
# 对定位到的元素执行鼠标悬停操作
ActionChains(driver).move_to_element(above).perform()

……

from selenium.webdriver import ActionChains

导入提供鼠标操作的 ActionChains 类。

ActionChains(driver)

调用 ActionChains()类，将浏览器驱动 driver 作为参数传入。

move_to_element(above)

context_click()方法用于模拟鼠标右键操作，在调用时需要指定元素定位。

测试投入与产出

Tue, 17 Jun 2025 17:29:15 +0800

在测试人员分工中，我介绍了各种分工方式，在选择使用哪一种分工方式时，还需要考虑投入的人员数量，投入的时间，与发现缺陷的数量。

#### 投入时间与发现缺陷的关系： ---- ![](http://img.testclass.net/time_and_bug.png)

在人员一定的情况下，投入的时间越多，发现的缺陷越多。但有一个规律，越到后期发现的新缺陷越少。假设软件总缺陷为100个，第一周发现50个问题，第二新发现20个，第二周可能只发现10个新缺陷。而且一个必然的结果是，测试不可能发现所有的缺陷。

#### 投入人员数量与缺陷的关系： ---- ![](http://img.testclass.net/personnel_and_bug.png)

在时间一定有的情况下，投入的人员越多，发现的问题越多，从图中可以看出，投入的人员越多，人员发现缺陷的重叠度越高。当然，你可以说，把每个人员要测试的内容划分清晰就不会重叠了。做为一个系统的各个功能模块，他们之间肯定存在必然的联系。有可能A人员在测试时会涉及到B人员测试的功能，并且发现了问题，不管是告诉B缺陷还是A人员直接提交缺陷（当然，你也可以装作没看到，等着B去发现），这都算不可避免的重叠。

当然，划分更清晰的任务有效的降低重叠度。同步也降低了发现缺陷的数量，提高项目风险。除非投入更多的时间测试。这之间的关系，需要测试管理者认真去权衡。

在项目不紧急测试时间充分的情况下，可以投入更少的人员，延长测试时间发现更多的缺陷。在项目紧急的情况下，需要投入更多的人员测试，以便尽快的发现更多的缺陷。在项目质量要求很高的情况下需要投入更多的人员与时间进行测试。在测试时间少，项目质量要求不高的情况下，可以投入较少的人员与时间进行测试。

原始封面

python简明教程: 7. 高级内容

Fri, 16 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 7. 高级内容
####################################################

# 生成器
# 生成器会动态生成一些数据，而不是在使用数据前创建数据然后把这些数据储存起来

# 下面的方法(非生成器)会将所有的值翻倍，并存在double_arr变量里
# 如果iterable很大的话，double_arr将是巨大的
def double_numbers(iterable):
 double_arr = []
 for i in iterable:
 double_arr.append(i + i)
 return double_arr


# 运行下面的代码意味着我们首先会将所有的值都加倍然后返回回来
# 最后再检查返回值是否符合特定条件
for value in double_numbers(range(1000000)): # `test_non_generator`
 print value
 if value > 5:
 break


# We could instead use a generator to "generate" the doubled value as the item
# is being requested
# 我们可以使用生成器来动态加倍必要的值

def double_numbers_generator(iterable):
 for i in iterable:
 yield i + i


# 使用生成器运行之前同样的代码
# 现在我们可以根据运行时逻辑一个接一个的进行加倍
# 一旦value > 5，代码就会break
# 这样我们就不需要把所有的值都加倍一遍了(运行速度会快很多)
for value in double_numbers_generator(xrange(1000000)): # `test_generator`
 print value
 if value > 5:
 break

# BTW: 你注意到`range` 用在了 `test_non_generator` 而`xrange` 用在 `test_generator`里了嘛?
# 就像`double_numbers_generator` 是 `double_numbers`的生成器版本一样
# `xrange` 是`range`的生成器版本
# `range` 会返回包含1000000个值的列表
# `xrange` 会在我们遍历的时候动态依次创建1000000个值

# 你也可以像使用列表表达式一样使用生成器表达式
values = (-x for x in [1, 2, 3, 4, 5])
for x in values:
 print(x) # 打印出-1 -2 -3 -4 -5

# 你也可以直接把生成器转换成列表
values = (-x for x in [1, 2, 3, 4, 5])
gen_to_list = list(values)
print(gen_to_list) # => [-1, -2, -3, -4, -5]


# 装饰器
# 装饰器是高阶函数，可以接受函数作为参数并返回函数
# 简单的例子 – add_apples装饰器会将 'Apple' 元素插入 into
# 到目标函数(被装饰的函数)get_fruits返回的列表里
def add_apples(func):
 def get_fruits():
 fruits = func()
 fruits.append('Apple')
 return fruits
 return get_fruits

@add_apples
def get_fruits():
 return ['Banana', 'Mango', 'Orange']

# 打印出的结果里是包含'Apple'元素的
# Banana, Mango, Orange, Apple
print ', '.join(get_fruits())

# 下面的例子里beg 装饰了 say
# Beg会调用say. 如果 say_please 是 True 那么 beg 会修改say的返回值
# message
from functools import wraps


def beg(target_function):
 @wraps(target_function)
 def wrapper(*args, **kwargs):
 msg, say_please = target_function(*args, **kwargs)
 if say_please:
 return "{} {}".format(msg, "Please! I am poor :(")
 return msg

 return wrapper


@beg
def say(say_please=False):
 msg = "Can you buy me a beer?"
 return msg, say_please


print say() # Can you buy me a beer?
print say(say_please=True) # Can you buy me a beer? Please! I am poor :(

原始封面

（七）创建docker selenium容器

Mon, 22 Jan 2018 14:36:11 +0800

SeleniumHQ官方项目：https://github.com/seleniumHQ/docker-selenium 项目目前快速迭代中。

Selenium

这里主要针对的是 Selenium Grid，它用于分布式自动化测试，就是一套Selenium 代码可在不同的环境上运行。刚好，Docker可快速的创建各种环境。

Selenium Grid 有两个概念

hub ：主节点，你可以看作 “北京总公司的测试经理”。

node：分支节点，你可以看作 “北京总公司的测试小兵A” 和 “上海分公司的测试小兵B”，还有 “深圳分公司的测试小兵C” …。

也就是说在Selenium Grid中只能有一个主hub，但可以在本地或远程建立 N 多个分支node，测试脚本指向主hub，由主hub 分配给本地/远程node 运行测试用例。

docker selenium 环境安装

以Ubuntu为例，在Ubuntu下安装Docker，请参考：Docker安装（Ubuntu）

docker hub（仓库）：

https://hub.docker.com/r/selenium/hub/

1、下载主hub镜像（北京总公司的测试经理）

$ sudo docker pull selenium/hub

2、下载主node chrome 镜像（上海分公司的测试小兵B）

$ sudo docker pull selenium/node-chrome

3、查看镜像

$ sudo docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
selenium/node-chrome latest 1eba57bd3d79 12 days ago 823MB
selenium/hub latest d1437f7d9f87 12 days ago 285MB

4、启动主hub容器

（七）类与对象

Wed, 17 Jan 2018 14:35:11 +0800

Java是一门面向对象的语言，其重要的一个思想就是 “万物皆对象”。从某中意义上讲，类是Java面向对象性的基础，Java的任何工作都要在类中进行。

类

创建一个 “程序员” 类，人一般属性包括姓名、性别、年龄、住址等。他的行为吃饭、睡觉、写代码等。


class Programmer {

 /**
 /声明各类变量来描述程序类的属性
 */
 String name;
 String sex;
 int age;
 String address;

 void eat(){
 System.out.println("我在吃饭！");
 }

 void sleep(){
 System.out.println("我在睡觉！");
 }

 void code(){
 System.out.printf("我在写代码！");
 }

}

注意，这个类在创建时并没有加 public 的修饰符，关于修饰符的权限：

private: 只有本类可见。
protected：本类、子类、同一包的类可见。
default(无修饰符)：本类、同一包的类可见。
public：对任何类可见。

在上面的代码中，你可以用以上修饰符进行修饰。类、变量、和方法。如下：

public class Programmer {

 /**
 /声明各类变量来描述程序类的属性
 */
 protected String name;
 protected String sex;
 protected int age;
 protected String address;

 public void eat(){
 System.out.println("我在吃饭！");
 }

 public void sleep(){
 System.out.println("我在睡觉！");
 }

 public void code(){
 System.out.printf("我在写代码！");
 }

}

对象

前面已经把描述对象的类抽象出来，接下来就是创建些类的实例。

TDD实战（七）Jacoco 代码覆盖率

Mon, 08 Jan 2018 12:35:11 +0800

最后一节，和TDD没有直关系，我这里要介绍代码覆盖率工具 Jacoco 。

安装 Jacoco

由于整个TDD项目由 Gradle构建，所以在build.gradle文件中添加 Jacoco 插件。

group 'org.tdd.sample'
version '1.0-SNAPSHOT'

apply plugin: 'java'
apply plugin: "jacoco" //Jacoco 插件

sourceCompatibility = 1.8

repositories {
 mavenCentral()
}

dependencies {
 testCompile group: 'junit', name: 'junit', version: '4.12'
}

运行测试

切换到TDD 项目目录。执行：

TDD > gradle clean test jacocoTestReport

BUILD SUCCESSFUL in 2s
5 actionable tasks: 5 executed

测试报告

在项目...\TDD\build\reports\jacoco\test\html目录下生成index.html报告，通过浏览器打开。

Android测试（七）：Espresso 自动化测试

Wed, 20 Dec 2017 14:25:12 +0800

原文：https://developer.android.com/training/testing/ui-testing/espresso-testing.html

在单个应用程序中测试用户交互有助于确保用户在与应用程序进行交互时不会遇到意外的结果，或遇到糟糕的体验。如果需要验证应用的UI功能是否正常，则应该养成创建用户界面（UI）测试的习惯。

Espresso 测试框架，由Android测试支持库提供，用于编写UI测试的API来模拟单个应用程序内的用户交互。Espresso测试可以在运行Android 2.3.3（API等级10）及更高版本的设备上运行。使用Espresso的一个关键好处是，它提供了测试操作与正在测试的应用程序的用户界面的自动同步。 Espresso检测主线程是否处于空闲状态，以便能够在适当的时候运行测试命令，从而提高测试的可靠性。此功能还可以减轻在测试代码中添加任何计时变通方法如Thread.sleep（） 的麻烦。

Espresso测试框架基于instrumentation的API，并通过AndroidJUnitRunner运行测试。

设置Espresso

在使用Espresso构建UI测试之前，请确保配置测试源代码位置和项目依赖关系，如“ Getting Started with Testing”中所述。

在Android应用程序模块的build.gradle文件中，必须设置对Espresso库的依赖关系引用：

dependencies {
    // Other dependencies ...
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

关闭测试设备上的动画 - 在测试设备中打开系统动画可能会导致意外的结果，或者可能导致测试失败。通过打开“开发人员”选项关闭“设置”中的动画，并关闭以下所有选项：

窗口动画比例
过渡动画比例
动画师持续时间比例

如果你希望将项目设置为使用核心API提供的Espresso功能以外的功能，请参阅此资源

创建一个Espresso 测试

要创建Espresso测试，请创建遵循此编程模型的Java类：

1.找到想要在活动中测试的UI组件(例如，应用程序中的登录按钮)，调用onView()方法，或者调用AdapterView控件的onData()方法。

2.通过调用ViewInteraction.perform（）或DataInteraction.perform（）方法并传入用户操作（例如，单击登录按钮），模拟特定的用户交互以在该UI组件上执行。要在同一UI组件上对多个操作进行排序，请使用方法参数中的逗号分隔列表链接它们。

3.根据需要重复上述步骤，模拟目标应用中多个活动的用户操作。

4.在执行这些用户交互之后，使用ViewAssertions方法来检查UI是否反映了期望的状态或行为。

以下各节将详细介绍这些步骤。

下面的代码片段显示了你的测试类可能如何调用这个基本的工作流程：


onView(withId(R.id.my_view))            // withId(R.id.my_view) is a ViewMatcher
        .perform(click())               // click() is a ViewAction
        .check(matches(isDisplayed())); // matches(isDisplayed()) is a ViewAssertion

使用Espresso和ActivityTestRule

以下部分介绍如何使用JUnit 4样式创建新的Espresso测试，并使用ActivityTestRule来减少需要编写的样板代码的数量。通过使用ActivityTestRule，测试框架在每个使用@Test注释的测试方法之前以及在使用@Before注释的方法之前启动被测活动。测试完成后，框架处理关闭活动，所有使用@After注释的方法都会运行。

另一个例子: 知乎最热问题

Wed, 13 Dec 2017 02:52:34 +0800

需求

在这一节里，我们将实现获取知乎每日及每月最热问题的功能。

具体步骤

访问知乎的发现的主页，获取html文本
分析html文本，找出今日最热和本月最热的html特征
解析html代码，拿到所有满足条件的链接
拿到链接的文本，并打印

分析html代码

<a class="question_link" href="/question/264469853/answer/281600357" target="_blank" data-id="20218891" data-za-element-name="Title">
如何看待张召忠（局座）于12月22日在b站的《荒野行动》直播？
</a>

稍微分析一下可以看出，我们只需要拿到所有class=“question_link"的a标签就可以了。

代码

# zhihu.py
import requests
from bs4 import BeautifulSoup

url = 'https://www.zhihu.com/explore'
headers = {'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36'}

soup = BeautifulSoup(requests.get(url, headers=headers).text, 'html.parser')

for link in soup.find_all('a', class_='question_link'):
 print(link.text)

运行

命令行中运行

python zhihu.py

预期结果

由于内容是动态的，所以结果应该跟我的结果不尽相同

如何看待美税改通过后各大公司的发福利提最低工资追加投资等行为？


全球变暖是必然吗？


主播进行游戏直播并从中获得打赏盈利涉及侵犯版权吗？


如何看待张召忠（局座）于12月22日在b站的《荒野行动》直播？


影史上有哪些经典的即兴表演镜头？


十年坚持做一件事，是种怎样的体验？


2018 年应届硕士毕业生如何拿到知名互联网公司深度学习 offer？


迄今为止你见过的最惊艳的建筑是？


有哪些令人心碎的小故事？


有哪些轻松幽默而又不低俗的段子或图片？


为什么人会失去婴儿时期的记忆？最早记忆是几岁呢？


你最喜欢的故事是什么？


做一个可爱的女孩子是一种什么体验？

原始封面

（七）使用注解来快速模拟

Sat, 25 Nov 2017 12:35:11 +0800

在前面的测试中我们在每个测试方法里都mock了一个List对象，为了避免重复的mock，是测试类更具有可读性，我们可以使用下面的注解方式来快速模拟对象：

import org.junit.Test;
import org.mockito.Mock;
import static org.mockito.Mockito.*;

import java.util.List;

public class MockitoDemo2 {

 @Mock
 private List mockList;

 @Test
 public void shorthand(){
 mockList.add(1);
 verify(mockList).add(1);
 }
}

运行这个测试类你会发现报NullPointerException错，mock的对象为NULL，为此我们必须在基类中添加初始化mock的代码:

import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.mockito.Mockito.*;

import java.util.List;

public class MockitoDemo2 {

 @Mock
 private List mockList;

 public MockitoDemo2(){
 MockitoAnnotations.initMocks(this);
 }

 @Test
 public void shorthand(){
 mockList.add(1);
 verify(mockList).add(1);
 }
}

或者使用built-in runner：MockitoJUnitRunner:

（七）TestNG 用例执行顺序

Sat, 25 Nov 2017 12:30:11 +0800

有时候，我们希望用例按照我们要求的顺序来执行。TestNG 同样可以满足这一点要求。

实例

import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;


public class CaseRunTest {

 @Test
 public void testCase1(){
 assertEquals(2+2, 4);
 }

 @Test
 public void testCase2(){
 assertEquals(2+2, 4);
 }

 @Test
 public void testCase3(){
 assertEquals(2+2, 4);
 }
}

通过 testng.xml 文件修改配置。

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="测试套件">
 <test name="简单测试" preserve-order="false">
 <classes>
 <class name="test.sample.CaseRunTest">
 <methods>
 <include name="testCase3" />
 <include name="testCase1" />
 <include name="testCase2" />
 </methods>
 </class>
 </classes>
 </test>
</suite>

preserve-order 参数用于控制测试用例的执行顺序。如果为：true，测试用例的顺序为：testCase > testCase1 > testCase2。如果为:false ，那么默认会按照用例的名称的有字母/数字的顺序执行：testCase1 > testCase2 > testCase3。

不设置的情况下默认为 true 。

requests如何在url中传递参数?

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

我们经常需要在请求中加参数，比如一些分页信息，每页返回的资源数量等。

如果我们手工去构造这些参数的话，我们会在url后面接?，然后传入key/value对，比如httpbin.org/get?key=val。多个key/value对以&分隔。

在Requests里，我们一般使用params关键字参数的方式，传入dict来传递url参数。比如，假设我们想传递key1=value1和key2=value2这2个参数，我们可以用下面的代码

>>> payload = {'key1': 'value1', 'key2': 'value2'}
>>> r = requests.get('http://httpbin.org/get', params=payload)

可以通过url方法来查看requests帮我们构造的编码后的url

>>> print(r.url)
http://httpbin.org/get?key2=value2&key1=value1

我们还可以为同一个key传递一组数据，比如

>>> payload = {'key1': 'value1', 'key2': ['value2', 'value3']}

>>> r = requests.get('http://httpbin.org/get', params=payload)
>>> print(r.url)
http://httpbin.org/get?key1=value1&key2=value2&key2=value3

原始封面

（七）JUnit 断言方法

Mon, 13 Nov 2017 12:35:11 +0800

JUnit 断言方法

JUnit 所提供的断言方法:

方法	说明
assertArrayEquals(expecteds, actuals)	查看两个数组是否相等。
assertEquals(expected, actual)	查看两个对象是否相等。类似于字符串比较使用的equals()方法。
assertNotEquals(first, second)	查看两个对象是否不相等。
assertNull(object)	查看对象是否为空。
assertNotNull(object)	查看对象是否不为空。
assertSame(expected, actual)	查看两个对象的引用是否相等。类似于使用“==”比较两个对象。
assertNotSame(unexpected, actual)	查看两个对象的引用是否不相等。类似于使用“!=”比较两个对象。
assertTrue(condition)	查看运行结果是否为true。
assertFalse(condition)	查看运行结果是否为false。
assertThat(actual, matcher)	查看实际值是否满足指定的条件。
fail()	让测试失败。

例子

关于断言方法，我们前面用得最多的是 assertEquals ，用于断言两个对象是否相等。这里再介绍一个 assertTrue 的使用。

创建 AssertTest 测试类（包了含被测试方法）：

import org.junit.*;
import static org.junit.Assert.*;


public class AssertTest {

 /**
 * 判断一个数是否为素数
 */
 public static Boolean Prime(int n) {
 for (int i = 2; i < Math.sqrt(n); i++) {
 if (n % i == 0) {
 return false;
 }
 }
 return true;
 }

 @Test
 public void testPrime(){
 int n = 7;
 assertTrue(AssertTest.Prime(n));
 }

}

Prime() 方法用于判断一个数是否为素数（只能被1和它本身整除的数），并返回 True 或 False ，在测试用例中通过 assertTrue 来断言结果。

7. 各种断言方法

Sat, 04 Nov 2017 06:23:31 +0800

背景

unittest支持各种断言方法。

断言列表

官方文档

方法	检查点
assertEqual(a, b)	a == b
assertNotEqual(a, b)	a != b
assertTrue(x)	bool(x) is True
assertFalse(x)	bool(x) is False
assertIs(a, b)	a is b
assertIsNot(a, b)	a is not b
assertIsNone(x)	x is None
assertIsNotNone(x)	x is not None
assertIn(a, b)	a in b
assertNotIn(a, b)	a not in b
assertIsInstance(a, b)	isinstance(a, b)
assertNotIsInstance(a, b)	not isinstance(a, b)
assertRaises(exc, fun, args, *kwds)	fun(args, *kwds) raises exc
assertRaisesRegexp(exc, r, fun, args, *kwds)	fun(args, *kwds) raises exc and the message matches regex r
assertAlmostEqual(a, b)	round(a-b, 7) == 0
assertNotAlmostEqual(a, b)	round(a-b, 7) != 0
assertGreater(a, b)	a > b 2.7
assertGreaterEqual(a, b)	a >= b
assertLess(a, b)	a < b
assertLessEqual(a, b)	a <= b
assertRegexpMatches(s, r)	r.search(s)
assertNotRegexpMatches(s, r)	not r.search(s)
assertItemsEqual(a, b)	sorted(a) == sorted(b) 也支持unhashable对象
assertDictContainsSubset(a, b)	a里面所有的键值对都在b中存在

自己动手

大家可以自己动手亲自尝试使用这些断言方法。

7. 获取用户输入

Wed, 01 Nov 2017 08:17:22 +0800

获取用户的输入

大部分的软件可能都需要接收用户的输入，比如

登录的功能，需要用户输入用户名密码之类
发微信，需要用户输入发送的信息
美化图片，需要用户选择滤镜等

这一节里我们将学习怎么从命令行里获取用户的输入。

在python里，我们可以简单的使用input()函数来获取用户输入的信息，并保存在变量里。

在调用input(message)函数时，我们可以在命令行将message打印出来展示给用户。

背景

我们实现个简单的用例生成器，通过提示用户输入用例的相应部分，最后组合成1个完整的用例。

代码实现

新建名为gen_test_case.py，内容如下


case_name = input("请输入用例名称:\n")
test_data = input("请输入用到的测试数据，比如: 测试站点=www.itest.info:\n")
test_steps = input("请输入测试步骤:\n")
test_assert = input("请输入测试断言(预期结果):\n")

formatter = """
用例名称: {}
测试数据: {}
测试步骤: {}
测试断言: {}
"""

print(formatter.format(case_name, test_data, test_steps, test_assert))

运行

在命令行中使用下面的命令去执行代码

$python gen_test_case.py

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

请输入用例名称:
正常登录
请输入用到的测试数据，比如: 测试站点=www.itest.info:
用户名=example;密码=example
请输入测试步骤:
略
请输入测试断言(预期结果):
测试断言: 应该跳转到www.itest.info/login_success页面，并出现"登录成功"的提示

用例名称: 正常登录
测试数据: 用户名=example;密码=example
测试步骤: 略
测试断言: 测试断言: 应该跳转到www.itest.info/login_success页面，并出现"登录成功"的提示

动手时间

在命令行里输入python -m pydoc input，看一下输出的结果是什么
在查看pydoc的时候，按q可以退出
去网络上搜索一下pydoc的作用是什么
使用pydoc去了解一下open, file, os和sys的作用

原始封面

7.常见套路

Sat, 28 Oct 2017 07:22:42 +0800

在使用pytest的时候，下面这些问题我们可能会经常遇到，这里给出官方的解决方案，按照套路来执行就可以了。

基础用法

参数化

原始封面

7. 判断元素是否存在

Tue, 24 Oct 2017 06:55:26 +0800

is_element_present

判断元素是否存在。所有的容器类(BasePage, Container和Logical Container)都有is_element_present方法，如果对应名称的元素在页面上存在，该方法返回true。

from selenium.webdriver.common.by import By
from webium import BasePage, Find

class PresencePage(BasePage):
 class_info = Find(by=By.CSS_SELECTOR, value='a[href*="/newclass"]')
 faq = Find(by=By.CSS_SELECTOR, value='a[href*="/faq"]')

 def __init__(self):
 super(PresencePage, self).__init__(url='http://itest.info')


if __name__ == '__main__':
 page = PresencePage()
 page.open()
 print('This should be True: ' + str(page.is_element_present('class_info')))
 print('This should be False: ' + str(page.is_element_present('no_such_link')))

注意：如果是通过Finds去定位的一组元素，我们也可以调用is_element_present方法来判断这组元素的存在性。如果这一组元素全部存在，返回True,如果有任意1个元素不存在，返回False。

just_in_dom

默认情况下，is_element_prasent方法只有在这个元素可见的时候返回True。如果我们需要元素存在于dom中就返回True的话，那么设置just_in_dom=True

timeout

timeout是等待is_element_prasent返回True的时间，单位是秒。

print('This should be True: ' + str(page.is_element_present('class_info', just_in_dom=True, timeout=3)))

原始封面

收藏清单: python测试框架最全资源汇总

Fri, 20 Oct 2017 08:19:06 +0800

xUnit frameworks(单元测试框架)

frameworks 框架
- unittest - python自带的单元测试库，开箱即用
- unittest2 - 加强版的单元测试框架，适用于Python 2.7以及后续版本
- pytest - 成熟且功能强大的单元测试框架
- plugincompat - pytest的执行及兼容性插件
- nosetests - 让python测试更容易一点
- slash - python实现的单元测试框架
extensions 扩展
- proboscis - 仿TestNG扩展了unittest模块以及Nose的功能
- grail - 可以让你一步一步编写测试用例的库
- testify - 单元测试框架，提供了加强型fixture，用例切割并行运行，testrunner高亮及详尽的log和report功能
- trial - unittest模块的扩展，提供了命令行的testrunner工具以及代码覆盖率的整合，跟nose差不多
- subunit - 提供了unittest在另一个进程执行用例并汇总测试数据的能力
- testresources - 提供了多用例间管理测试数据的机制，兼容unittest
- testtools - 为Twisted和Bazaar提供的unittest扩展
- Sancho - 运行用例，并为失败的用例提供报告，但仅限于此
- zope.testing - testrunner，提供了不错的debuge能力，并且集成了代码覆盖率。可以跟zope项目使用，也可以用在非zope项目上
- pythoscope - 自动或半自动为遗留的python系统创建测试用例的工具
- testlib - 更强大的unittest，更多的断言，支持module级的setup/teardown，skip test等…
- dutest - An object oriented interface to retrieve unittest test cases out of doctests. Hides initialization from doctests by allowing setUp and tearDown for each interactive example. Allows control over all the options provided by doctest. Specialized classes allow selective test discovery across a package hierarchy.
- green - Green是一个简洁多彩的testrunner，跟nose很像
- ddt - 让unittest 支持 Data-Driven
- pytractor Selenium python bindings的扩展. 目的是让angular项目的测试更简单

TDD \ ATDD \ BDD

BDD
- behave - BDD 框架
- lettuce - 又一个BDD框架
  - lettuce-tools - 一整套lettuce扩展，让BDD更加简单
- contexts - Python的描述性测试工具
- mamba - python的definitive testing 工具
- pyvows - 异步的行为驱动开发测试工具
- pytest-bdd - py.test runner的BDD库
- robotframework - 最有名的acceptance test-driven development (ATDD)测试框架
  - awesome-robotframework - 各种rf的扩展库
- radish-bdd - BDD框架，支持gherkin语言
Assertions 断言
- pyshould - 基于pyhamcrest的Should style断言
- pyhamcrest - python版的Hamcrest matchers
- sure -python实现的测试库,提供了强大灵活的断言
- assertpy - 巨简单的python单元测试断言库，提供了优雅流利的API. 支持Python 2 和 3.
Mocking
- mock - python实现的Mocking和Patching库
- Ludibrio - 用python实现的优雅的test doubles框架(mocks, stubs, spy, and dummies).
- responses - mock请求的 Python测试工具库
- doublex - 强大的 test doubles 框架
- freezegun - 通过mocking datetime模块实现时光穿梭
- httpretty - HTTP请求的mock工具
- httmock - requests的mock工具，支持Python 2.6+ and 3.2+.
- pretenders - 测试用的fake server
- mock-server - 简单的mock sever，支持REST and XML-RPC API，还有基于tornado的管理界面
- VCR.py - 自动 mock HTTP 交互让测试更简单快速

原始封面

（七）实战：构建 GitHub 项目(中)

Mon, 16 Oct 2017 11:50:11 +0800

前提工作已经完成，接下来创建 GitHub 的项目构建。

创建 GitHub 项目的构建

1、新建项目

在 Jenkins 首页，点击 “新建”。

设置项目名称：GitHub project

选择“构建一个自由风格的软件项目”

2、添加 GitHub 上的项目

勾选 * GitHub Project 选项

Project url ：设置 github 的项目地址。

3、设置Git

勾选 * Git 选项

Repository URL: 填写 GitHub 项目地址
credentials ：设置资格证书，听过 add 添加账号。
Branch Specifier(blank for ‘any’) ：默认 */master 不用修改。

4、设置触发条件

（七）Locust 的类和方法

Mon, 16 Oct 2017 09:00:11 +0800

针对你的业务，你如何进行测试测试，需要通过编写性能测试脚本实现。所以，我们要熟悉 Locust 提供了哪些类和方法，它们分别实现什么操作。

HttpLocust 类

from locust import HttpLocust, TaskSet, task

class UserTask(TaskSet):

 @task
 def tc_index(self):
 self.client.get("/")

class UserOne(HttpLocust):
 task_set = UserTask
 weight = 1
 min_wait = 1000
 max_wait = 3000
 stop_timeout = 5
 host = "https://www.baidu.com"

class UserTwo(HttpLocust):
 weight = 2
 task_set = UserTask
 host = "https://www.baidu.com"

每一个模拟的用户可以看做一个 HttpLocust 类的实例，HttpLocust 类有如下属性：

task_set

指向一个 TaskSet 类，TaskSet 类定义了每个用户的行为。

min_wait

用户执行任务之间等待时间的下界，单位：毫秒。如果TaskSet类中有覆盖，以TaskSet 中的定义为准。

max_wait

用户执行任务之间等待时间的上界，单位：毫秒。如果TaskSet类中有覆盖，以TaskSet中的定义为准。

host

如果是 Web 服务的测试，host 相当于是提供 URL 前缀的默认值，但是如果在命令行中指定了 --host 选项，则以命令行中指定的为准。如果不是 Web 服务测试，使用默认的 None 就好。

stop_timeout

设置 Locust 多少秒后超时，如果为 None ,则不会超时。

weight

一个Locust实例被挑选执行的权重，数值越大，执行频率越高。在一个 locustfile.py 文件中可以同时定义多个 HttpLocust 子类，然后分配他们的执行权重，例如：

然后在终端启动测试：

> locust -f load_test.py UserOne UserTwo

TaskSet 类

TaskSet类定义了每个用户的任务集合，测试任务开始后，每个 Locust 用户会从 TaskSet 中随机挑选一个任务执行，然后随机等待 HttpLocust 类中定义的 min_wait和 max_wait 之间的一段时间，执行下一个任务。

07. 首次运行向导（新用户必看）

Mon, 16 Oct 2017 07:00:11 +0800

首次运行

向导功能

假如你计算机上在过去已经有安装过 IntelliJ IDEA 14 的版本，且你在卸载 IntelliJ IDEA 的过程中，IntelliJ IDEA 的配置文件目录都没有删除，那安装新版本之后是不会有首次运行的功能向导的。

假如你计算机上没有安装过 IntelliJ IDEA，或是卸载 IntelliJ IDEA 过程中你删除了 IntelliJ IDEA 的配置文件目录，则当你双击运行桌面上的 IntelliJ IDEA 快捷图标，将进入下面介绍的向导过程。

上图第一个单选按钮表示 IntelliJ IDEA 识别到我计算机上有 IntelliJ IDEA 13 版本的旧配置，如果我选择了该选项，则 IntelliJ IDEA 将自动把旧版本的配置文件转移到新版本的配置文件目录上。如果你计算机上首次安装一般是没有该选项的。

上图第二个单选按钮表示你可以指定 IntelliJ IDEA 导入你计算机上存在其他目录的 IntelliJ IDEA 配置文件目录，如果你有的话。

上图第三个单选按钮表示你没有任何早期版本的 IntelliJ IDEA 配置，你不导入任何配置，让 IntelliJ IDEA 生成一份新的配置。

（七）soapUI设置Auth

Wed, 20 Sep 2017 20:00:11 +0800

#### 设置用户认证（Auth） ---- 当我们请求一个接口时，一般需要认证，认证是判断用户是否有请求权限的常用手段。

参考前面学习的添加 SOAP 和 REST 请求。

点击 “Request 1” 窗口左下角 “Auth” 按钮，Authoriaztion 选项中选择 “add New Authoriaztion” ，在弹出的窗口中 Type 选择 “Basic” 选项，点击 “OK” 按钮，如下图。

添加认证用户,如下图。

填写用户认证 Username 和 Password ，勾选 “Authenticate pre-emptvely” 选项。

Username：用于填写基本认证的用户名。

Password：用于填写基本认证的密码。

Domain：域名是基本认证的可选项，设置为空。

Pre-emptive auth：设置定义认证的行为。

Use global preference ：用于定义HTTP设置为全局首选项。
Authenticate pre-emptively：仅适用于此请求，不需要等待身份验证质询时发送凭据。

原始封面

appium新手入门（7）—— Desired Capabilities

Thu, 07 Sep 2017 10:24:12 +0800

从后台统计来看，appium 系列的教程很受欢迎！于是，我继续更新，也希望你把这个教程推荐给更多学习 appium 的小伙伴！

Desired Capabilities

Desired Capabilities 在启动 session 的时候是必须提供的。

Desired Capabilities 本质上是以 key value 字典的方式存放，客户端将这些键值对发给服务端，告诉服务端我们想要怎么测试。它告诉 appium Server这样一些事情：

本次测试是启动浏览器还是启动移动设备。
是启动Andorid还是启动iOS。
启动Android时，app的package是什么。
启动Android时，app的activity是什么。
…

Desired Capabilities 配置

Appium 的 Desired Capabilities 基本配置如下：


DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("deviceName", "Android Emulator");
capabilities.setCapability("automationName", "Appium");
capabilities.setCapability("platformName", "Android");
capabilities.setCapability("platformVersion", "5.1");
capabilities.setCapability("appPackage", "com.android.calculator2");
capabilities.setCapability("appActivity", ".Calculator");

WebDriver driver = new AndroidDriver(new URL("http://127.0.0.1:4723/wd/hub"), capabilities);

deviceName：启动哪种设备，是真机还是模拟器？iPhone Simulator，iPad Simulator，iPhone Retina 4-inch，Android Emulator，Galaxy S4…
automationName：使用哪种自动化引擎。appium（默认）还是Selendroid。
platformName：使用哪种移动平台。iOS, Android, orFirefoxOS。

JMeter官方文档：7. 创建FTP测试计划

Thu, 24 Aug 2017 10:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

7.创建FTP测试计划

在这一章，你将学习如何创建一个基础的测试计划来测试FTP站点。你将在一个FTP站点上的两个文件中创建四个用户来发送请求。并且，你将告诉用户运行测试两次。所以，总的请求数是（4个用户）x（2个请求）x（重复2次）=16 FTP请求。

为了构造测试计划，你需使用以下元件：线程组，FTP请求，FTP默认请求和用表格察看结果。

7.1 添加用户

你要进行每一个JMeter测试计划的第一步是添加一个线程组元件。线程组告诉JMeter你想要模拟的用户数量，用户应该发送请求的频率，以及他们应该发送多少个请求。继续添加线程组元件，首先选择测试计划，点击鼠标右键添加菜单，然后选择 添加→线程组。

现在你应该看到 测试计划 下的 线程组 元件。如果没有看到元件，单击测试计划元件“展开”测试计划树。

接下来，你需要修改默认配置。如果你还没有选择 线程组 元件，在测试计划树里选择它。现在你应该在JMeter窗口右侧看到线程组控制面板(请参见下面的图7.1)

图7.1 默认值的线程组

首先为我们的线程组取一个更具描述性的名称。在名称文本域中，输入“FTP用户”。

接下来将用户数（线程数）增加到4。

在下一个文本域中，Ramp-Up Period（in seconds），使用默认值0秒。这个属性告诉JMeter在启动每个用户之间的时间间隔。例如，如果你在Ramp-Up Period（in seconds）中输入5秒，JMeter将在5秒内完成所有用户的启动。因此，如果我们有5个用户和一个5秒的Ramp-Up Period，那么启动用户之间的时间间隔将是1秒(5个用户/ 5秒= 1个用户每秒)。如果将值设置为0，则JMeter将立即启动所有用户。

最后，在循环次数中输入值2。这个属性告诉JMeter重复测试的次数。要让JMeter重复一直运行你的测试计划，勾选永远的复选框。

在大多数应用中你必须手动的保存你在控制面板中的改动。但是在JMeter中，控制面板能自动的保存你做的改动。比如你修改了一个元件的名称，在你离开控制面板后测试计划树会以新的文本来更新（比如选择另一个树元件时）。

看下图7.2 中完整的FTP Users线程组。

图7.2 FTP Users线程组

7.2 添加默认FTP请求配置

既然我们已经定义了我们的用户，那么是时候定义他们要执行的任务了。在本节中，你将为你的FTP请求指定默认设置。然后，在7.3节中，使用你在这里指定的一些默认设置中添加 FTP请求 元件。

Google测试工师的一道面试题目

Thu, 24 Aug 2017 09:44:38 +0800

最近重读《Google软件测试之道》，其中有一道面向软件测试工程师的面试题非常考验测试人员的思维。拿来与你们分享，看看这样一道题，你能想到多少个测试点。

题目：

在一个Web测试页面上，有一个输入框，一个计数器（count）按钮，用于计算一个文本字符串中字母a出现的个数。这里的问题是，请设计一系列字符串用以测试这个Web页面。

题目非常简单，看到这个题目不要上来就开始设计用例，最好能有一些思考，这样看起来更加“专业”。

（题外话，我在参加产品需求评审的时候也会问许多问题，尤其是产品需求并没完全确定下来的时候，站在用户的角度，我也是用户啊，我是否喜欢这个功能？）

所以，我第一个想到的是设计这个功能的背景，因为同样一个功能，在不同的背景下，测试需要考虑的点可能是不一样的。例如，同样是一个搜索功能，百度的搜索和淘宝的搜索就有很大不同，因为用户的使用场景完全不同，输入搜索的关键字和预期结果也不一样。

当然，这只是一道题，你根据题目回答就好了。

不过，我们仍然可以就题目本身来提一些问题：大写还是小写？只是英文么？计算完成后文本会被清除码？多次按下按钮会发生什么事情？…..

接下来你假装有条不紊的设计用例（思考一会儿，然后再输入一串字符，然后再思考…），而不是看起来像monkey试图破坏软件（拼命的敲击键盘…）。

“banana”：3（一个合法的英文字）。
“A” 和“a”：1（一个简单有正常结果的合法输入）。
“”：0（一个简单的结果为0的合法输入）。
Null：0（简单的错误输入）。
“AA” 和“aa”：2（个数大于1并且所有字符都为a/A的输入）。
“b”：0（一个简单的非空合法输入，结果为0）。
“aba”：2（目标字符出现在开头和结尾，以寻找循环边界错误）。
“bab”：1（目标字符出现在中间）。
space/tabs：N（空白字符与N个a的混合）。
不包含a的长字符串：N（N大于0）。
包含a的长字符串：N（N是a的倍数）。
{java/C/HTML/JavaScript}：N是a出现的个数（可执行字符，或错误，或代码解释）。
…

更优秀的测试工程师，应该跳出输入本身，设计以下用例。

质疑界面的外观、调色板和对比度（这与相关应用风格一致么？）
文本框太小了，建议加长以便显示更长的输入字符串
这个应用能否在同一台服务器上运行多个实例，多个用户同时使用是否会有问题。
是否会根据用户的输入自动匹配内容？
建议使用真实的数据，如从词典或书中选择输入内容。
提出疑问：“输入的数据是否会被保存”，输入字符串可能包含地址或其他身份信息。
输入HTML和JavaScrip，看是否会破坏页面渲染。
尝试复制/粘贴字符串。
提出疑问：“计算足够快么？在大并发下使用”。
提出提问：“用户怎么找到该页面？”

还有一些测试点，只有经验丰富的测试工程师才会想到。

意识到计算会通过URL-encodedHTTP GET请求传递到服务器，字符串可能会在网络传输时被截断，因此，无法保证支持多长的URL。
建议将此功能参数化，为什么只对字母a计算呢？
考虑计算其它语言中的a（α，Alpha）。
考虑到该应用是否应该国际化。
考虑编写脚本或者手工采样来探知字符串长度的上限，然后确保在此区间内功能正常。
考虑背后的实现和代码。也许已经有一个计数器遍历该字符串。
提出疑问：“HTTP POST方法和参数会被黑掉码？也许有安全漏洞？”
用脚本创建各种有趣的排列组合和字符串特性，如长度、a的个数等，自动生成测试输入和验证。

原始封面

7.requests库

Thu, 24 Aug 2017 04:41:43 +0800

requests库可以极大的简化我们发送http请求及获取响应的代码，简洁而优雅。

简单示例

>>> import requests
>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
u'{"type":"User"...'
>>> r.json()
{u'private_gists': 419, u'total_private_repos': 77, ...}

上面的例子相信大家很容易看明白，在我们做接口自动化测试的时候，我们往往使用requests的提供的接口发送请求和获取响应，并根据响应类型将响应转换成python自建的数据结构。比如上面的例子里，我们将响应的json字符串转换成了python的dict。

安装

官方文档中文文档

快速开始

官方文档中文文档

划重点

英文不好的同学可以参考中文文档的相关章节。

appium简明教程（7）——Desired Capabilities详解

Mon, 14 Aug 2017 08:01:35 +0800

Desired Capabilities在启动session的时候是必须提供的。

Desired Capabilities本质上是key value的对象，它告诉appium server这样一些事情：

本次测试是启动浏览器还是启动移动设备？
是启动andorid还是启动ios？
启动android时，app的package是什么？
启动android时，app的activity是什么？

Appium的Desired Capabilities是扩展了webdriver的Desired Capabilities的，下面的一些通用配置是需要指定的：

automationName：使用哪种自动化引擎。appium（默认）还是Selendroid？
platformName：使用哪种移动平台。iOS, Android, orFirefoxOS？
deviceName：启动哪种设备，是真机还是模拟器？iPhone Simulator, iPad Simulator, iPhone Retina 4-inch, Android Emulator, Galaxy S4, etc…
app：应用的绝对路径，注意一定是绝对路径。如果指定了appPackage和appActivity的话，这个属性是可以不设置的。另外这个属性和browserName属性是冲突的。
browserName：移动浏览器的名称。比如Safari’ for iOS and ‘Chrome’, ‘Chromium’, or ‘Browser’ for Android；与app属性互斥。
udid：物理机的id。比如1ae203187fc012g。

下面这些属性是android平台特定的：

appActivity：待测试的app的Activity名字。比如MainActivity, .Settings。注意，原生app的话要在activity前加个"."。
appPackage：待测试的app的java package。比如com.example.android.myApp, com.android.settings。

本文主要讨论android平台的appium测试方法和技巧，因此在这里就不列出ios设备特定的属性了。

更多信息请参考官方文档

在这里我们发现，我们经常要获取app的package和activity名字，那么有什么工具可以让我们方便的获取到这些信息呢？下一节讲回答这个问题。

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

原始封面

性能测试流程（二）——了解系统架构

Fri, 11 Aug 2017 07:59:11 +0800

系统架构对于测试新手来是最难的；先来了解系统所使用的技术和框架，在环境搭建阶段，你需要了解项目的部署；在性能分析与调优阶段，更要深入这些技术的细节去分析。

下面看一个基本的系统架构：

表示层

表示层（浏览器）通过前端技术（HTML5/JavaScript/CSS3）将系统功能和数据展示给用户，并与用户实现交互。通过TCP/HTTP协议与业务层系统通信，向应用层系统发送请求报文，并接收应用层系统返回的响应报文。

业务逻辑层

业务逻辑层作为中间层实现核心业务逻辑服务。

应用服务器主要运行中间件系统，中间件系统系统作为一个容器来运行各种应用软件系统。前台发来的请求报文通过中间件传递给应用程序，应用程序在处理的过程中调用数据层的数据服务器，数据服务器将查询的数据返回给应用程序，应用软件处理完成后通过中间件系统返回给客户端。

在大型的系统中，可以对应用系统进行拆分，比如拆分成交易服务，查询服务；或者通过负载均衡技术，来分散客户端发来的请求，使其能承受更大的用户访问量。

数据层

数据层运行在数据库主机上，负责整个系统中数据信息的存储。运行数据库服务程序，查询通过JDBC与应用程序进行通信，主要用于存储数据与提供数据查询等服务。

数据库集群技术就是对大型系统应用非常广泛的一种解决方案。

前面介绍了一般系统的架构，那么一个大型的系统在设计中使用了哪些手段或技术来提高系统的性能呢？下面通过一张图来了解一下。

常用的系统架构:

· Linux + Apache + PHP + MySQL

· Linux + Nginx + Redis + PHP + MySQL

· Linux + Apache + Tomcat + Java+ Oracle

· Windows Server 2003/2008 + IIS + C#/ASP.NET + 数据库

· Window Server 2003/2008 + tomcat + MySql/Oracle/ + Java

（七）通过linkText去定位页面上的元素

Mon, 07 Aug 2017 02:59:32 +0800

链接的定位

链接可以使用By.linkText和By.partialLinkText的方式去定位。

链接的html标签是<a></a>。

看这个html代码<a href="http://www.itet.info">这就是linkText<a>，这里**[这就是linkText]** 便是这个链接的linkText，partialLinkText指的是部分的链接文本，如果链接的文本过长的时候，使用partialLinkText会起到简化代码的作用。

目的

熟悉selenium webdriver 定位方式
学会通过linkText和partialLinkText属性去定位元素
学会使用getAttribute()方法获取html元素的属性
学会使用then()方法传入回调函数来搞定Thenable的Promise

练习对象

我们使用html5-test-page作为我们的练习对象。

将html代码拷贝一份并保存到本地，文件名为index.html。

场景

定位下面html代码所示的a元素，并打印这些元素的href属性

<ul>
 <li><a href="#text__headings">Headings</a></li>
 <li><a href="#text__paragraphs">Paragraphs</a></li>
 <li><a href="#text__blockquotes">Blockquotes</a></li>
 <li><a href="#text__lists">Lists</a></li>
 <li><a href="#text__hr">Horizontal rules</a></li>
 <li><a href="#text__tables">Tabular data</a></li>
 <li><a href="#text__code">Code</a></li>
 <li><a href="#text__inline">Inline elements</a></li>
</ul>

代码

var path = require('path');
var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var testFile = "file://" + path.join(__dirname, "index.html");

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get(testFile);

dr.findElement(By.linkText('Headings')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.linkText('Paragraphs')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.linkText('Blockquotes')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.linkText('Lists')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.linkText('Horizontal rules')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.linkText('Tabular data')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.linkText('Code')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.findElement(By.partialLinkText('Inline')).getAttribute('href').then(function(href) {
 console.log(href);
});

dr.quit();

运行结果

xxxx代表你的本机index.html的路径

（七）测试投入与产出

Thu, 20 Jul 2017 12:59:11 +0800

在测试人员分工中，我介绍了各种分工方式，在选择使用哪一种分工方式时，还需要考虑投入的人员数量，投入的时间，与发现缺陷的数量。

#### 投入时间与发现缺陷的关系： ---- ![](http://img.testclass.net/time_and_bug.png)

#### 投入人员数量与缺陷的关系： ---- ![](http://img.testclass.net/personnel_and_bug.png)

原始封面

（七）WebDriver常用方法

Sun, 02 Jul 2017 07:37:11 +0800

前面我们已经学习了定位元素，定位只是第一步，定位之后需要对这个元素进行操作，或单击（按钮）或输入（输入框），下面就来认识这些最常用的方法。

WebDriver 常用方法

下面先来认识 WebDriver 中最常用的几个方法：

clear() 清除文本。
sendKeys(*value) 模拟按键输入。
click() 单击元素

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class BaiduDemo {

 public static void main(String[] args) {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com/");

 WebElement search_text = driver.findElement(By.id("kw"));
 WebElement search_button = driver.findElement(By.id("su"));

 search_text.sendKeys("Java");
 search_text.clear();
 search_text.sendKeys("Selenium");
 search_button.click();

 driver.quit();
 }
}

clear()方法用于清除文本输入框中的内容。

（七）键盘事件

Sat, 24 Jun 2017 12:59:11 +0800

Keys()类提供了键盘上几乎所有按键的方法。前面了解到， send_keys()方法可以用来模拟键盘输入，除此之外，我们还可以用它来输入键盘上的按键，甚至是组合键，如 Ctrl+A、 Ctrl+C 等。

from selenium import webdriver
# 引入 Keys 模块
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome()
driver.get("http://www.baidu.com")

# 输入框输入内容
driver.find_element_by_id("kw").send_keys("seleniumm")

# 删除多输入的一个 m
driver.find_element_by_id("kw").send_keys(Keys.BACK_SPACE)


# 输入空格键+“教程”
driver.find_element_by_id("kw").send_keys(Keys.SPACE)
driver.find_element_by_id("kw").send_keys("教程")

# ctrl+a 全选输入框内容
driver.find_element_by_id("kw").send_keys(Keys.CONTROL, 'a')

# ctrl+x 剪切输入框内容
driver.find_element_by_id("kw").send_keys(Keys.CONTROL, 'x')

# ctrl+v 粘贴内容到输入框
driver.find_element_by_id("kw").send_keys(Keys.CONTROL, 'v')

# 通过回车键来代替单击操作
driver.find_element_by_id("su").send_keys(Keys.ENTER)
driver.quit()

需要说明的是，上面的脚本没有什么实际意义，仅向我们展示模拟键盘各种按键与组合键的用法。

from selenium.webdriver.common.keys import Keys

在使用键盘按键方法前需要先导入 keys 类。

以下为常用的键盘操作：

send_keys(Keys.BACK_SPACE) 删除键（BackSpace）
send_keys(Keys.SPACE) 空格键(Space)

软件测试流程

Tue, 17 Jun 2025 17:29:15 +0800

如果想让测试在公司的项目中发挥出它最大的价值，并不是招两个测试技术高手，或引入几个测试技术，而是测试技术对项目流程的渗透，以及测试流程的改进与完善。虽然，当然测试行业前景乐观，许多中小企业也都在引入测试，但一百个公司就有一百种测试，每个公司对测试的看法不同，公司对测试的定位也不完全一样。

#### 简陋的测试流程

先说我入职的第一个家公司，我是第一个入职的专职测试人员，相信一两个测试的公司还是不少的，入职后各种项目都在进行当中，上面给我的定位是并没完全融入到项目中去。而通过指派任务的方式。

下面是简陋的流程图：

需求分析与架构设计：

我们做的是某一移动公司内部使用的项目，需求分析与架构全部由项目经理完成，之后由项目经理给具体某个开发人员分配任务，具体对某个功能模块的实现。这个对项目经理的经验与技术要求很高，他既然担任了需求分析师，又担任架构师的角色。

程序员编码：

因为我们开发语言用的是JAVA 语言，IDE用MyEclipse中自带的CVS版本管理工具，开发人员完成代码后，提交到版本库中。

测试：

我入职后的第一个任务是搭建缺陷管理工具，禅道项目管理，通过推广对发现的问题进行跟踪。后来正明效果并不好，因为对于一个六七人的开发团队项目，开发人员更喜欢测试人员能当面反馈，这样更能提高效率。对一个小 bug 通过当面交流的方式就可以将问题修复。

对于当时的环境，并没有测试环境。开发人员在本机上将项目进行部署运行。测试人员通过局域网访问开发人员的机子进行测试。或在测试人员本机上进行部署测试。这也是一个致命的缺点。因为开发人员测试人员使用的电脑存在太多不稳定因素，这些都会造成问题的出现，有时候难以判定是系统问题还是环境问题。

上线：

经过测试人员测试通过后，开发人员部署上线。

A程序员流程

你会发现在流程图中，A程序员是先发上线之后，再进行测试。这是我们一个面向大众用户的网站，上面给于测试人员的定位是测试兼用户体验，测试将发现的bug和体验问题提交到缺陷管理系统，由经理对问题进行分析，指派开发人员解决。定期对系统进行更新。

流程分析：

这个流程唯一的优点，就是能快速的发现并修复问题。

缺点就非常多了，相信许多小软件公司也有类似的流程。

这个流程中，项目经理是核心，项目经理也确实是有多年开发与项目经验的牛人，他喜欢不定期分享上些前沿的技术。

对于测试来说，需求很不明确，测试文档与用例也是可有可无的产物，没有需求文档，或非常简陋，根据需求文档根本无法编写用例。我只能收集一些通用的测试用例，如登录、文件上传下载、列表翻页、日期选择、输入框验证、搜索等有一些“通用型”用例，以便在测试过程中做参考。功能测试的多了，拿到一个功能，测试思路也就出来了。

#### 规范的测试流程 ----

放弃上份悠闲的工作，感谢那个带我入行公司，我想了解真正的测试在公作中如何进行的。所以，来到了现在这家公司。我很欣喜的是这测试有自己的团队，专业（对当时的我来说）的流程，以及与开发等同的地位。

现在的测试流程：

需求分析：

需求分析由产品人员制定，他们要做的不是一份简单的文档，而是细化每一个功能的细节，每一个按钮的位置，对于稍大或复杂一点的需求都进行建模。

需求评审：

这里会叫上所有参与项目人员进行，开发人员、测试人员、QA人员。测试人员提出需求，开发人员考虑功能实现的方案与可行性、当然开发负责人也是要参与的。测试人员主要是对需求的理解提出疑问，以便才能根据需求写用例。QA人员是最终对软件质量进行验证的人，所以也需要了解需求

开发人员编写排期：

开发人员需要根据需求功能点进行排期。然后将开计划转交给测试人员。

测试计划排期：

测试人员根据开发计划，对测试具体测试时间，也就是开发功能完成后的时间，进行几轮测试等。然后，把项目的开发与测试计划发送给各部门负责人及参与项目的所有人员。

编写测试用例：

根据详细的需求分档，开始进行用例的编写。

用例评审：

在用例进行评审期间，先以邮件形式将用例发送给相关人员，以便他们事先了解用例对哪些功能进行验证以及验证的细节。

然后，测试人员组进行用例评审，开发人员对用例与实际功能不符合有哪些，产品人员对会通过用例对功能的具体实现进行把握等等。

提交基线：

开发人员完成所有功能后，会对自己的功能进行一个自测。自测完成后提交测试人员进行基线。

具体测试流程：

开发人员对于基到测试线的功能进行测式，发现的问题通过缺陷管理工具进行反馈，开发人员对问题进行修复，然后，准备第二轮基线。

测试人员完成第一轮测试后，需要写测试结论，发到相关人员。然后对基线后的第二轮进行测试，第二轮会对第一轮中发现的问题进行重点回归。

测试通过：

经过两到三轮或四轮的测试后，直到没发现新的问题，或暂时无法解决，或不紧急的问题。通过上级确认，可以通过。编写测试报告与验收方案。

验收方案是交由QA进行验证的。在现公司的流程中是将测试与QA分开的，测试人员重点关注的是功能是否可以正常运行。QA关注的是整个流程的质量以及最终用户的质量。有些公司QA与测试是不区分的，但这对测试的要求会更高，除了关心功能，还需要关心整体流程与质量。

流程分析：

对于刚接触这个流程的我来说，这个流程是规范的，测试真正融入了整个流程，而且还担任了很重的角色，从而也有效的保证了软件产品的整体质量。

（八）Docker Dockerfile

Mon, 22 Jan 2018 14:32:11 +0800

虽然，前面已经会使用 Nginx 和 docker selenium 来启动容器，但也仅仅是会使用，Dcoker 中还有许多概念和细节需要我们继续学习。

Dockerfile 文件分析

Dockerfile 由一行行命令语句组成，并且支持以 # 开头的注释行。

一般的 Dockerfile 分为四部分：基础镜像信息、 维护者信息、 镜像操作指令 和 容器启动时执行指令 。

以Selenium/Hub 的 Dockerfile 文件为例:

# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# NOTE: DO *NOT* EDIT THIS FILE. IT IS GENERATED.
# PLEASE UPDATE Dockerfile.txt INSTEAD OF THIS FILE
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FROM selenium/base:3.8.1-erbium
LABEL authors=SeleniumHQ

USER seluser

#========================
# Selenium Configuration
#========================

EXPOSE 4444

# As integer, maps to "maxSession"
ENV GRID_MAX_SESSION 5
# In milliseconds, maps to "newSessionWaitTimeout"
ENV GRID_NEW_SESSION_WAIT_TIMEOUT -1
# As a boolean, maps to "throwOnCapabilityNotPresent"
ENV GRID_THROW_ON_CAPABILITY_NOT_PRESENT true
# As an integer
ENV GRID_JETTY_MAX_THREADS -1
# In milliseconds, maps to "cleanUpCycle"
ENV GRID_CLEAN_UP_CYCLE 5000
# In seconds, maps to "browserTimeout"
ENV GRID_BROWSER_TIMEOUT 0
# In seconds, maps to "timeout"
ENV GRID_TIMEOUT 30
# Debug
ENV GRID_DEBUG false
# As integer, maps to "port"
ENV GRID_HUB_PORT 4444

COPY generate_config \
 entry_point.sh \
 /opt/bin/
# Running this command as sudo just to avoid the message:
# To run a command as administrator (user "root"), use "sudo <command>". See "man sudo_root" for details.
# When logging into the container
RUN /opt/bin/generate_config > /opt/selenium/config.json

CMD ["/opt/bin/entry_point.sh"]

FROM

Dockerfile 都必须以 FROM 命令开始。 FROM命令会指定镜像基于哪个基础镜像创建，接下来的命令也会基于这个基础镜像。

（八）构造方法

Wed, 17 Jan 2018 14:32:11 +0800

构造方法

构造方法用于初始化一个新建的对象，如果你没有定议任何构造方法的形式，程式会为你取一个不带任何参数的构造函数，那么你产生类的对像时只能用不带参数的方法。

1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2.每个类可以有一个以上的构造器
3.构造器可以有 0 个、 1 个或 1 个以上的参数
4.构造器没有返回值
5.构造器总是伴随着 new 操作一起调用


public class Father {

 public Father() {
 System.out.println("调用了无参的构造函数.");
 }

 public Father(String msg) {
 System.out.println("调用了有参的构造函数： " + msg);
 }

 public static void main(String args[]) {
 Father f1 = new Father();
 Father f2 = new Father("Hello");
 }
}

运行结果：

调用了无参的构造函数.
调用了有参的构造函数： Hello

构造函数中"super"用法

构造方法和普通方法都用会关键字 super 指向父类，但是用的方法不一样。在构造方法中，调用父类中的某一个构造函数。在构造方法中的用法。

Android测试（八）：UI Automator 自动化测试

Wed, 20 Dec 2017 14:20:12 +0800

原文：https://developer.android.com/training/testing/ui-testing/uiautomator-testing.html

涉及跨多个应用程序的用户交互的用户界面（UI）测试可以验证应用程序在用户流量跨越其他应用程序或进入系统UI时的行为。这种用户流程的一个例子是一个消息应用程序，它允许用户输入文本消息，启动Android联系人选择器，以便用户可以选择收件人发送消息，然后将控制权返回给用户的原始应用程序并提交消息。

这一小节介绍如何使用Android测试支持库提供的UI Automator测试框架编写此类UI测试。 UI Automator API可让你与设备上的可见元素进行交互，而不管哪个Activity处于焦点。你的测试可以使用方便的描述符（如该组件中显示的文本或其内容描述）查找UI组件。 UI Automator测试可以在运行Android 4.3（API级别18）或更高版本的设备上运行。

UI Automator测试框架是基于 instrumentation的API，并与AndroidJUnitRunner测试运行器一起使用。

设置UI Automator

在使用UI Automator构建UI测试之前，请确保配置测试源代码位置和项目依赖关系，如前面章节中所述。

在Android应用程序模块的build.gradle文件中，必须设置对UI Automator库的依赖关系引用：

dependencies {
    ...
    androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.1'
}

为了优化您的UI Automator测试，您应该首先检查目标应用程序的UI组件，并确保它们可以访问。这些优化技巧将在下面两节中介绍。

查看设备上的UI

在设计您的测试之前，检查设备上可见的UI组件。为确保您的UI Automator测试可以访问这些组件，请检查这些组件是否具有可见的文本标签、android:contentDescription 值。

uiautomatorviewer工具提供了一个方便的可视化界面来检查布局层次结构，并查看设备前台中可见的UI组件的属性。这个信息可以让你使用UI Automator创建更细致的测试。例如，可以创建一个匹配特定可见属性的UI选择器。

启动uiautomatorviewer工具：

1.在物理设备上启动目标应用程序。

2.将设备连接到你的开发机器。

3.打开终端窗口并导航到<android-sdk> / tools /目录。

4.使用以下命令运行该工具：

$ uiautomatorviewer

要查看您的应用程序的UI属性：

1.在uiautomatorviewer界面中，点击 Device Screensho 按钮。

2.将鼠标悬停在左侧面板中的快照上，查看由uiautomatorviewer工具标识的UI组件。属性列在右下方的面板中，右上方的布局层次中列出。

3.或者，单击 Toggle NAF Nodes 按钮以查看UI Automator无法访问的UI组件。这些组件只有有限的信息可用。

确保你的Activity是可访问的

UI Automator测试框架对已实施Android辅助功能的应用程序执行得更好。当你使用View类型的UI元素或SDK或Support Library中的View的子类时，不需要实现可访问性支持，因为这些类已经为你完成了。

但是，有些应用程序使用自定义UI元素来提供更丰富的用户体验。这些元素不会提供自动的可访问性支持。如果你的应用程序包含不是来自SDK或支持库的View子类的实例，请确保通过完成以下步骤将可访问性功能添加到这些元素：

1.创建一个扩展ExploreByTouchHelper的具体类。

2.通过调用setAccessibilityDelegate（）将新类的实例与特定的自定义UI元素相关联。

有关将辅助功能添加到自定义视图元素的其他指导，请参阅构建可访问自定义视图要详细了解Android上可访问性的一般最佳实践，请参阅使应用程序更易于访问。

（八）TestNG 用例依赖

Sat, 25 Nov 2017 12:25:11 +0800

当某一条用例运行失败时，其它用例必然也会失败，所以，我们就没有必要再运行其它用例了，这个时候我们就可以设置用例之间的依赖。

测试方法依赖

import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;


public class DependentMethodsTest {

 @Test
 public void testAdd1(){
 assertEquals(3+1, 5);
 }

 @Test(dependsOnMethods = {"testAdd1"})
 public void testAdd2(){
 assertEquals(3+2, 5);
 }

}

dependsOnMethods 来设置用例的依赖，当 testAdd1() 运行失败时，则 testAdd2() 不再被执行。

测试组依赖

import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;


public class DependentGroupsTest {

 @Test(groups={"funtest"})
 public void testAdd1(){
 assertEquals(3+1, 5);
 }

 @Test(groups={"funtest"})
 public void testAdd2(){
 assertEquals(3+2, 5);
 }

 @Test(dependsOnGroups = {"funtest"})
 public void testAdd3(){
 assertEquals(3+2, 5);
 }

}

dependsOnGroups 来设置组的依赖，testAdd1()和 testAdd2() 同属于于 funtest组，testAdd3() 依赖于funtest组，该组有中有一条用例运行失败，则testAdd3() 不再执行。

原始封面

requests如何获取响应的状态码?

Wed, 22 Nov 2017 03:23:57 +0800

使用status_code 就可以了。

>>> r = requests.get('http://httpbin.org/get')
>>> r.status_code
200

为方便引用，Requests还附带了一个内置的状态码查询对象：

>>> r.status_code == requests.codes.ok
True

如果发送了一个错误请求(一个 4XX 客户端错误，或者 5XX 服务器错误响应)，我们可以通过 Response.raise_for_status() 来抛出异常：

>>> bad_r = requests.get('http://httpbin.org/status/404')
>>> bad_r.status_code
404

>>> bad_r.raise_for_status()
Traceback (most recent call last):
 File "requests/models.py", line 832, in raise_for_status
 raise http_error
requests.exceptions.HTTPError: 404 Client Error

如果在测试用例中直接使用raise_for_status()方法，如果有异常抛出的话，用例会自动失败。

原始封面

（八）JUnit 测试批量运行

Mon, 13 Nov 2017 12:30:11 +0800

前面测试用例的运行主要针对单个测试类进行的，当然，在 IntelliJ IDEA 中也可以选择单个的方法执行。那如果我们想运行所有的用例的文件呢？

IntelliJ IDEA 中设置运行

设置

在 IntelliJ IDEA 中，菜单栏：Run菜单 –> Edit Configurations…选项。

在 Junit 目录下，选择任意一个用例文件。

Test Kind : 选择用例的运行类型/级别。
packages : 选择用例运行的目录，即你的测试用例目录。

设置完成后，点击 “OK” 按钮。

运行

点击 IntelliJ IDEA 工具栏上的运行按钮，来运行 test 目录下的所有用例。

运行结果：

通过测试套件运行

这种方法引入一种 “测试套件” 的概念，JUnit 提供了一种批量运行测试类的方法，叫测试套件。

测试套件的写法需要遵循以下原则：

8. 断言异常

Thu, 02 Nov 2017 06:23:31 +0800

背景

我们有时候需要断言一些方法会抛出异常，这些异常需要符合我们的预期。

代码

新建test_exception.py文件，内容如下

import unittest

class DivZeroTestCase(unittest.TestCase):

 def test_should_raise_exception(self):
 with self.assertRaises(ZeroDivisionError):
 1 / 0

if __name__ == '__main__':
 unittest.main()

运行及结果

$ python test_exception.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

我们能学到什么

上面的例子断言了当0作为除数的时候会抛出ZeroDivisionError
断言异常是有套路的，使用with语句加assertRaises，assertRaises的参数中传入预期的异常(这些异常可能需要先import进来)，在with的子句中放上会抛出异常的语句或表达式

原始封面

8. 命令行参数与unpack

Tue, 31 Oct 2017 08:17:22 +0800

背景

我们先稍微的修改一下上一节的用例生成器，加入接收命令行参数的功能。

作为测试用例的执行者，我们希望在创建用例的时候可以指定用例编号，以便能够更加系统的管理测试用例。

代码实现

新建名为gen_test_case_with_id.py，内容如下


from sys import argv

script, case_id = argv
print(f"创建测试用例\n用例编号: {case_id}")
case_name = input("请输入用例名称:\n")
test_data = input("请输入用到的测试数据，比如: 测试站点=www.itest.info:\n")
test_steps = input("请输入测试步骤:\n")
test_assert = input("请输入测试断言(预期结果):\n")

formatter = """
用例编号: {}
用例名称: {}
测试数据: {}
测试步骤: {}
测试断言: {}
"""

print(formatter.format(case_id, case_name, test_data, test_steps, test_assert))

运行

在命令行中使用下面的命令去执行代码

$python gen_test_case_with_id.py itest_001

注意：我们在脚本名称后面加上了itest_001，这就是我们指定的用例编号，千万不要忘记传入这个参数，否则代码将会报如下的错误

Traceback (most recent call last):
 File "gen_test_case_with_id.py", line 3, in <module>
 script, case_id = argv
ValueError: not enough values to unpack (expected 2, got 1)

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

创建测试用例
用例编号: itest_001
请输入用例名称:
登录成功
请输入用到的测试数据，比如: 测试站点=www.itest.info:
无
请输入测试步骤:
略
请输入测试断言(预期结果):
跳转到www.itest.info

用例编号: itest_001
用例名称: 登录成功
测试数据: 无
测试步骤: 略
测试断言: 跳转到www.itest.info

import

python给我们预置了很多常用的功能，这些功能以module的形式组织起来，使用import关键字就可以把我们需要的内容导入进来，从而在脚本里使用。

8.使用pytest做简单的接口测试

Fri, 27 Oct 2017 07:22:42 +0800

背景

我们现在需要测试v2ex网站的查看论坛节点信息的api。具体如下:

节点信息

获得指定节点的名字，简介，URL 及头像图片的地址。

https://www.v2ex.com/api/nodes/show.json

Method: GET
Authentication: None
接受参数：

name: 节点名（V2EX 的节点名全是半角英文或者数字）
例如：

https://www.v2ex.com/api/nodes/show.json?name=python

接口返回

{
 "id" : 90,
 "name" : "python",
 "url" : "http://www.v2ex.com/go/python",
 "title" : "Python",
 "title_alternative" : "Python",
 "topics" : 7963,
 "stars" : 5138,

 "header" : "这里讨论各种 Python 语言编程话题，也包括 Django，Tornado 等框架的讨论。这里是一个能够帮助你解决实际问题的地方。",


 "footer" : null,

 "created" : 1278683336,
 "avatar_mini" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_mini.png?m=1509941286",
 "avatar_normal" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_normal.png?m=1509941286",
 "avatar_large" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_large.png?m=1509941286"
}

需求分析

该接口是获取数据的接口，一般来说，这种接口我们的测试重点是验证数据的准确性。

根据3A原则，我们可以设计如下的用例

测试数据: 节点的名称:python
接口地址: https://www.v2ex.com/api/nodes/show.json
断言: 返回的结果里，id必须是90,name必须等于python，大家想一想为什么？

代码

新建名为v2ex_api_test.py的文件，键入如下内容

8. 其他

Mon, 23 Oct 2017 06:55:26 +0800

wait

webium.wait.wait()是python wait库的简单封装。

具体实现看这里

settings

可以看成是webium的全局配置，有下面的一些配置项目，具体看这里

driver_class = Firefox # 默认的driver
implicit_timeout = 30 # 默认的隐式等待时间
wait_timeout = 30 # 等待超时时间

default_search_type = By.ID # 默认的定位策略

具体例子

import webium.settings
from selenium.webdriver import Chrome

webium.settings.implicit_timeout = 0
webium.settings.driver_class = Chrome

原始封面

（八）实战：构建 GitHub 项目(下)

Mon, 16 Oct 2017 11:45:11 +0800

其实，到些为止，整个项目已经创建完成。这一小节，只是为了验证创建的项目是否有效。

提交项目版本

修改 pyse 开源项目,并提交代码到 GitHub .

D:\git\pyse (master)
λ git commit -m "verison 0.0.8"

[master 270de98] verison 0.0.8
 6 files changed, 36 insertions(+), 32 deletions(-)
 create mode 100644 test_report.png

 D:\git\pyse (master)
 λ git push origin master

 Counting objects: 12, done.
 Delta compression using up to 4 threads.
 Compressing objects: 100% (11/11), done.
 Writing objects: 100% (12/12), 33.80 KiB | 11.27 MiB/s, done.
 Total 12 (delta 5), reused 0 (delta 0)
 remote: Resolving deltas: 100% (5/5), completed with 5 local objects.
 To https://github.com/defnngj/pyse
 c5b4c8a..270de98 master -> master

查看构建日志

通过 Jenkins 查看项目构建历史。

（八）Locust 设置断言

Mon, 16 Oct 2017 08:00:11 +0800

性能测试也需要设置断言么？某些情况下是需要，比如你在请求一个页面时，就可以通过状态来判断返回的 HTTP 状态码是不是 200。

设置响应断言

这里同样以测试百度首页为例。

from locust import HttpLocust, TaskSet, task

class UserTask(TaskSet):

 @task
 def job(self):
 with self.client.get('/', catch_response = True) as response:
 if response.status_code == 200:
 response.failure('Failed!')
 else:
 response.success()

class User(HttpLocust):
 task_set = UserTask
 min_wait = 1000
 max_wait = 3000
 host = "https://www.baidu.com"

catch_response = True ：布尔类型，如果设置为 True, 允许该请求被标记为失败。

通过 client.get() 方法发送请求，将整个请求的给 response，通过 response.status_code 得请求响应的 HTTP 状态码。如果不为 200 则通过 response.failure(‘Failed!’) 打印失败！

启动测试，运行情况：

至于，我上面的测试脚本为什么为失败，你自个分析一下吧！原因很简单。

原始封面

08. 安装后生成的目录说明、VM 设置（新用户必看）

Mon, 16 Oct 2017 05:00:11 +0800

IntelliJ IDEA 相关核心文件和目录介绍

安装目录介绍

IntelliJ IDEA 的安装目录并不复杂，上图为最常改动的 bin 目录，经常会改动的文件或是必须介绍就是如图红色框中的几个。

idea.exe 文件是 IntelliJ IDEA 32 位的可行执行文件，IntelliJ IDEA 安装完默认发送到桌面的也就是这个执行文件的快捷方式。

idea.exe.vmoptions 文件是 IntelliJ IDEA 32 位的可执行文件的 VM 配置文件，具体配置修改会下面进行专门讲解。

idea64.exe 文件是 IntelliJ IDEA 64 位的可行执行文件，要求必须电脑上装有 JDK 64 位版本。64 位的系统也是建议使用该文件。

idea64.exe.vmoptions 文件是 IntelliJ IDEA 64 位的可执行文件的 VM 配置文件，具体配置修改会下面进行专门讲解。

idea.properties 文件是 IntelliJ IDEA 的一些属性配置文件，具体配置修改会下面进行专门讲解。

强烈推荐不要直接修改安装目录下的这几个配置文件，因为 IDEA 升级/重装可能会导致修改完全失效！强烈推荐使用 IDEA 自带菜单中的 Help -> Edit Custom VM Options 和 Help -> Edit Custom Properties 来进行个性化配置！

（八）soapUI创建性能测试

Wed, 20 Sep 2017 20:00:11 +0800

这一节我们来介绍性能测试，以前面添加的 SOAP 项目为例。

（五）soapUI创建SOAP项目

创建测试用例

右键点击 “requests 1” 请求，选择 “Add to TestCase” …，如下图。

第一步，默认设置测试套件名为：TestSuite 1。

第二步，默认设置测试用例名为：TestCase 1。

第三步，添加 Requests 到测试用例，如下图。

点击 “OK” 完整测试用例的创建，如下图。

#### 创建性能测试用例 & 运行 ----

接下来，创建性能测试用例，右键点击 “Load Tests (1)” –> “New LoadTest” , 创建完成，参考上图，多出来一个 “LoadTest 1” 的选项。

最后，运行性能测试。在 “LoadTest 1” 窗口，点解右上角的绿色按钮，运行性能测试。

appium新手入门（8）—— 定位控件

Thu, 07 Sep 2017 10:24:12 +0800

appium 通过 uiautomatorviewer.bat 工具来查看控件的属性。该工具位于 Android SDK 的 /tools/bin/ 目录下。

id 定位

通过uiautomatorviewer.bat 工具可以查看对象的id属性。

如果目标设备的API Level低于18则UIAutomatorViewer不能获得对应的Resource ID，只有等于大于18的时候才能使用。

打开uiautomatorviewer.bat工具：

resource-id 就是我们理解的id属性了。

使用方法：

driver.findElement(By.id("com.android.calculator2:id/formula"))

name 定位

打开uiautomatorviewer.bat工具：

text就是我们要查找的name了，为什么在命名上毫无关联啊！

使用方法：

driver.findElement(By.name("9"))

class name 定位

计算器界面上的的class属性是：android.widget.Button。 使用方法：

WebElement button = driver.findElement(By.className("android.widget.Button"));

使用 Class Name 一般获得的 view 都不止一个，所以应该需要遍历一遍得到的 views，然后缩小搜索条件来获得目标控件。

XPath定位

在 WebDriver 上 XPath 定位是功能强大的一种定位方式。我个人惯用于此方法来定位Web页面上的元素。下面看看在 Android 上 XPath 定位的用法。

面试官问：说一个你工作中有价值的bug

Thu, 24 Aug 2017 09:44:38 +0800

这其实是前两天测试论坛上一个同学的问题，也是我以前面试时被问到一个问题，看到这个问题后，我的大脑开始搜索过去遇到的印象深刻或有价值的bug。

表面看这是一个非常简单的一个问题，做测试辣么久，发现的bug无数，随便从中挑选一个比较“特别”的一个bug说说就可以了啊！

但其实，越是从习以为常的事情中找“特别”越困难，比如，我每天中午都是楼下随便找一家快餐店吃饭，如果有人问我：说说你印象深刻的一次吃快餐的经历。除非我哪天吃出了苍蝇，否则怎么会对每天吃的快餐印象深刻。

同类的还有小学作文：《记最难忘的一件事》就很难写，别说对于小学生，对于成年人来说也一样，这其实跟你的文笔没太大关系。

但如果换一个问题：说说你如何测试面前的这把椅子？这个问题就简单太多了。

为什么前面让你描述一个bug就那么难，对一把椅子写测试用例就很简单呢？明明两个都是工作最常用的“知识”。

因为第一个问题太发散了嘛！我还要把以往有印象的bug在大脑中搜索一遍… 前几天测试的时候发现页面上有一个错别字，然后让开发改了，不行不行，这个太简单了，我要说这个bug，面试官会不会直接把我赶出来！？

继续想….

我们换位思考一下，面试官问这个问题的目的是什么？

其实，它并不关心你描述的这个bug是否真的有价值，或有多曲折离奇？他只是：

了解你平时工作中的测试能力

所以，这就要求的你平时工作中遇到bug时试着自己去定位，定位bug的过程远比你的单纯的执行测试用例有“价值”（自我技能提高的价值），在定位bug的过程中你需要掌握和运用更多知识。

另外，建议你平时养成总结的好习惯，发现的bug，开发解决了，最好问问他原因以及解决的方法，这样再遇到类似问题时，自己也可以试着定位解决。遇到难解决的bug，也可以把最终的解决过程记录下来。（这不是就有素材了）

考察你的表达能力

我们搞技术的有许多属于闷骚性格（我也是！），让我们和技术打交道游刃有余。在QQ群里聊天，也风趣、幽默、机智、博学…. 因为网络段子看多了嘛，再加上有百度加持。但面对公司会议或者和陌生人交流时，语言表达能力比较欠缺。

所以，建议你平时可以主动要求去分享一些自己工作中用到或学习的技术。或者多去参加集体活动，加强自己的表达能力。

也许就是想抛一个问题给你，自己好有时间继续看你的简历。

好了，大概了解的面试官的目的，那么可以在面试前事先思考一下这个问题，从工作中总结一些记忆深刻和有价值的bug。

如果，一时想不起来，可以这么切入，找一个自己工作中很熟悉的项目，然后，谈谈你是如何对这个项目进行测试的，然后，在某一个版本测试中，发现xxx，开发也xxxx，前端也xxxx，运维也xxxx，最后终于发现原来是xxx引起的xxxx 。

把你工作过程中的测试方法和步骤描述清楚了，那么这个bug有没有价值或是否印象深刻就不那么重要了。

如果你刚好去面试，加油！祝你好运！

原始封面

8.第一个用例

Wed, 23 Aug 2017 04:41:43 +0800

前面铺垫了很多的基础知识，掌握基础知识是做基于http接口自动化测试的前提，不建议直接跳过。

前提条件

学习本节需要有一些前提条件

安装了postman
安装了python
安装了requests

用例描述

在认识测试对象这一节里有过描述。


获得指定节点的名字，简介，URL 及头像图片的地址。

https://www.v2ex.com/api/nodes/show.json

Method: GET
Authentication: None
接受参数：

name: 节点名（V2EX 的节点名全是半角英文或者数字）
例如：

https://www.v2ex.com/api/nodes/show.json?name=python

# 响应

{
 "id" : 90,
 "name" : "python",
 "url" : "http://www.v2ex.com/go/python",
 "title" : "Python",
 "title_alternative" : "Python",
 "topics" : 7669,
 "stars" : 4870,

 "header" : "这里讨论各种 Python 语言编程话题，也包括 Django，Tornado 等框架的讨论。这里是一个能够帮助你解决实际问题的地方。",


 "footer" : null,

 "created" : 1278683336,
 "avatar_mini" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_mini.png?m=1504279401",
 "avatar_normal" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_normal.png?m=1504279401",
 "avatar_large" : "//v2ex.assets.uxengine.net/navatar/8613/985e/90_large.png?m=1504279401"
}

测试数据: 节点的名称:python
接口地址: https://www.v2ex.com/api/nodes/show.json
断言: 返回的结果里，id必须是90,name必须等于python，大家想一想为什么？

使用postman调试接口

在写用例之前，我们先在postman里把接口调通，大家可以参考之前这篇

appium简明教程（8）——那些工具

Sun, 13 Aug 2017 08:07:13 +0800

正所谓工欲善其事必先利其器，对于appium实战android来说，下面的这些工具(以windows系统为例)是必须熟练使用的。

monitor.bat（hierarchyviewer.bat已经不赞成继续使用了）

该文件位于your_andriod_sdk_path\tools下面。以乙醇的机器为例，其位于E:\adt-bundle-windows-x86-20131030\sdk\tools下。

该工具可以帮我们找到android控件的content-description，为以后的find_element_by_accessibility_id 定位方法做参数使用。

关于什么是content-description，可以参考官方文档。

好，露个脸。

uiautomatorviewer.bat

该文件位于your_andriod_sdk_path\tools下面。以乙醇的机器为例，其位于E:\adt-bundle-windows-x86-20131030\sdk\tools下。

该工具主要用来查看控件的属性，比如resource id，class name等。

该工具也可查看被测app的appPackage（Desired Capabilities中使用）。

爆照。

好了，是不是感觉还缺了点什么呢？

确实如此，被测app的appActivity怎么获取呢？

下一讲我们详细讲解如何获取被测app的appActivity。

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

原始封面

性能测试流程（三）——分析测试点

Fri, 11 Aug 2017 06:59:11 +0800

当你了解你的系统架构之后，接下来可以好好的分析一下性能测试点。因为这关系到你测试工具的选型。

性能测试点的选取

*　发生频率非常高的（例如：某邮箱核心业务系统中的登录、收发邮件等业务，它们在每天的业务总量中占到90%以上）

*　关键程度非常高的（产品经理认为绝对不能出现问题的，如登录等）

*　资源占用非常严重的（导致磁盘I/O非常大的，例如某个业务进行结果提交时需要向数十个表存取数据，或者一个查询提交请求时会检索出大量的数据记录）

对性能需求点的描述

准确

如**系统必须在不超过 10 秒的响应时间内，处理 20 起登录任务。再如发邮件时间最大不超过5秒以及平均时间在2秒以内。

一致

用户和性能测试工程师对有关术语的理解要一致，如:并发用户数、在线用户数、注册用户数:

特定

性能测试的需求一定是有条件的。

检查系统后台关键业务数据10G、操作数据量为20K，1500 个用户、500 个并发用户运行的负载下，连续运行12小时过程中，业务操作是否满足性能需求。

一般性能需求描述

1、Web首页打开速度5s以下，Web登陆速度 15s以下。

2、邮件服务支持50万个在线用户

3、计费话单成功率达到99.999%以上。

4、在100个并发用户的高峰期，邮箱的基本功能，处理能力至少达到10QPS(TPS). QPS(TPS)–每秒钟请求/事物数量

5、系统能在高于实际系统运行压力1倍的情况下，稳定的运行12小时。

6、这个系统能否支撑200万的VU（每天登录系统的人次） VU–Virtual user(虚拟用户)

原始封面

（八）通过css选择器去定位页面上的元素

Sun, 06 Aug 2017 03:41:18 +0800

css选择器

火狐的css教程应该是比较权威的css入门教程了。

对于selenium自动化测试来说，大家只需要掌握一些必备的css选择器知识就好了。

目的

熟悉selenium webdriver 定位方式
学会通过css选择器去定位元素

练习对象

我们使用html5-test-page作为我们的练习对象。

将html代码拷贝一份并保存到本地，文件名为index.html。

场景

定位下面html代码所示的输入框，并使用sendKeys输入一些内容。

<p>
 <label for="input__search">Search</label>
 <input id="input__search" type="search" placeholder="Enter Search Term">
</p>
<p>
 <label for="input__text2">Number Input</label>
 <input id="input__text2" type="number" placeholder="Enter a Number">
</p>
<p>
 <label for="input__text3" class="error">Error</label>
 <input id="input__text3" class="is-error" type="text" placeholder="Text Input">
</p>
<p>
 <label for="input__text4" class="valid">Valid</label>
 <input id="input__text4" class="is-valid" type="text" placeholder="Text Input">
</p>

代码

var path = require('path');
var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var testFile = "file://" + path.join(__dirname, "index.html");

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get(testFile);

// id selector
dr.findElement(By.css('#input__search')).sendKeys('测试教程网');
// attribute selector
dr.findElement(By.css('input[type="number"]')).sendKeys('66666');
// class selector
dr.findElement(By.css('.is-error')).sendKeys('should be error');
// class selector
dr.findElement(By.css('.is-valid')).sendKeys('should be valid');

运行结果

如下图所示

（八）软件测试流程

Thu, 20 Jul 2017 10:59:11 +0800

#### 简陋的测试流程

下面是简陋的流程图：

需求分析与架构设计：

程序员编码：

因为我们开发语言用的是JAVA 语言，IDE用MyEclipse中自带的CVS版本管理工具，开发人员完成代码后，提交到版本库中。

测试：

上线：

经过测试人员测试通过后，开发人员部署上线。

A程序员流程

流程分析：

这个流程唯一的优点，就是能快速的发现并修复问题。

缺点就非常多了，相信许多小软件公司也有类似的流程。

这个流程中，项目经理是核心，项目经理也确实是有多年开发与项目经验的牛人，他喜欢不定期分享上些前沿的技术。

#### 规范的测试流程 ----

现在的测试流程：

需求分析：

需求评审：

开发人员编写排期：

开发人员需要根据需求功能点进行排期。然后将开计划转交给测试人员。

测试计划排期：

编写测试用例：

根据详细的需求分档，开始进行用例的编写。

用例评审：

在用例进行评审期间，先以邮件形式将用例发送给相关人员，以便他们事先了解用例对哪些功能进行验证以及验证的细节。

然后，测试人员组进行用例评审，开发人员对用例与实际功能不符合有哪些，产品人员对会通过用例对功能的具体实现进行把握等等。

提交基线：

开发人员完成所有功能后，会对自己的功能进行一个自测。自测完成后提交测试人员进行基线。

具体测试流程：

开发人员对于基到测试线的功能进行测式，发现的问题通过缺陷管理工具进行反馈，开发人员对问题进行修复，然后，准备第二轮基线。

测试人员完成第一轮测试后，需要写测试结论，发到相关人员。然后对基线后的第二轮进行测试，第二轮会对第一轮中发现的问题进行重点回归。

测试通过：

经过两到三轮或四轮的测试后，直到没发现新的问题，或暂时无法解决，或不紧急的问题。通过上级确认，可以通过。编写测试报告与验收方案。

流程分析：

对于刚接触这个流程的我来说，这个流程是规范的，测试真正融入了整个流程，而且还担任了很重的角色，从而也有效的保证了软件产品的整体质量。

（八）模拟鼠标操作

Sun, 02 Jul 2017 07:37:11 +0800

通过前面例子了解到，可以使用click()来模拟鼠标的单击操作，现在的Web产品中提供了更丰富的鼠标交互方式，例如鼠标右击、双击、悬停、甚至是鼠标拖动等功能。在WebDriver中，将这些关于鼠标操作的方法封装在ActionChains类提供。

Actions 类提供了鼠标操作的常用方法：

contextClick() 右击
clickAndHold() 鼠标点击并控制
doubleClick() 双击
dragAndDrop() 拖动
release() 释放鼠标
perform() 执行所有Actions中存储的行为

百度首页设置悬停下拉菜单。

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;

public class MouseDemo {

 public static void main(String[] args) {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com/");

 WebElement search_setting = driver.findElement(By.linkText("设置"));
 Actions action = new Actions(driver);
 action.clickAndHold(search_setting).perform();

 driver.quit();
 }
}

import org.openqa.selenium.interactions.Actions;

导入提供鼠标操作的 ActionChains 类

（八）获取断言信息

Fri, 23 Jun 2017 12:59:11 +0800

不管是在做功能测试还是自动化测试，最后一步需要拿实际结果与预期进行比较。这个比较的称之为__断言__。

我们通常可以通过获取title 、URL和text等信息进行断言。text方法在前面已经讲过，它用于获取标签对之间的文本信息。下面同样以百度为例，介绍如何获取这些信息。

from selenium import webdriver
from time import sleep


driver = webdriver.Firefox()
driver.get("https://www.baidu.com")

print('Before search================')

# 打印当前页面title
title = driver.title
print(title)

# 打印当前页面URL
now_url = driver.current_url
print(now_url)

driver.find_element_by_id("kw").send_keys("selenium")
driver.find_element_by_id("su").click()
sleep(1)

print('After search================')

# 再次打印当前页面title
title = driver.title
print(title)

# 打印当前页面URL
now_url = driver.current_url
print(now_url)

# 获取结果数目
user = driver.find_element_by_class_name('nums').text
print(user)

driver.quit()

脚本运行结果如下：

Before search================
百度一下，你就知道
https://www.baidu.com/
After search================
selenium_百度搜索
https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0&rsv_idx...
搜索工具
百度为您找到相关结果约5,380,000个

title：用于获得当前页面的标题。
current_url：用户获得当前页面的URL。
text：获取搜索条目的文本信息。

原始封面

软件测试人员定位

Tue, 17 Jun 2025 17:29:15 +0800

工作已将近三年了，虽然这三个年头里我都在积极的学习着与测试相关的技术；但是能沉淀的东西很少。相信测试同学都有类似的感觉。

不要为了测试而测试

前几天做一个测试的PPT，就是讲项目中要用到的测试技术，总结了半天其实实际的产品中没用到什么技术含量的技能，熟悉需求，并转化成用例，待项目上线后验证功能就 OK了；对一个自身质量要求不高的项目，我们有时候为了体现自己价值，非要在一些不痛不养的问题上用力过猛。

举个不恰当例子，某钢琴高手开了一个补习班教钢琴，家长送来一孩子目的只是让孩子学学钢琴；钢琴高手为了体验自己的价值（牛B），硬是按照贝多芬的标准去培养，孩子弹不会《XX交响曲》不让孩子走。先不说孩子有没有贝多芬的钢琴天资，也许孩子压根就不想成为贝多芬。

当然了，如果你办的是“中国音乐家钢琴协会”，你有责任要求会员达到国际超一流水平，为国家和个人赢得荣誉。

有时候不要为了测试去测试，或为了体现自己的价值去做一些对整个项目贡献不大的事儿。当然，我在这里不是让测试人员放弃自己的原则。要知道不管是产品、开发、测试都是围绕着产品的发展贡献。

为贡献产品的发展测试远比为了测试了测试所带来的价值大得多；所以站在产品的发展上去看待测试工作更能体现自己的价值。

记得去年的总结自己对测试流程的理解。随着工作年龄的加长对这些问题也有进一步的看法；所以，再拿来炒一炒，希望能炒出新的味道。

没有最好的开发测试流程，只有最适合项目的开发测试的流程；

去年的一篇说软件测试流程，严格规范的测试流程一定比没流程好，敏捷的流程一定比传统的瀑布流程先进。这个观点没有大的错误，但是我们忽略了所做的产品这个“对象”；忽略了产品的特点与阶段。

例如两三个开发合伙开发一个项目（或产品），这时你让他们建立一套规范的流程，按流程实施，显然是不现实，我想摆在他们面前最主要的问题是，如何快速的把客户需要的功能开发出来换成money ，维持生计以及公司运作。

例如一个各种功能已经成熟的项目，有着庞大的用户群，以维护为主的更新，它的版本功能的上线必须要建立严格的发布流程，经过充分的测试才能上线；用户群越大，暴露的问题越多，问题带来的影响也会越大。

同样是一个Web产品，笔者目前所做的项目流程完全不是这样；我们的发布流程很简单，测试流程也很简单，不去写的规范又复杂的测试用例，放弃了使用缺陷管理工具来反馈问题；

沟通变得尤为重要；我不否认这样做会给产品带来了一定的风险；对于严重的问题，我们可以通过快速的版本回滚，对于轻微的问题，我们很快会在下个版本迭代中修复。是不是有点敏捷的味道在里面。

为什么会这样？因为这个产品属于前期开发阶段，很多功能还没上线。整个团队都在贡献着产品的发展；需要快速的将需求转化成功能给用户使用。

所以，没有最好的开发测试流程，只有最适合项目与阶段的开发测试的流程。

#### 产品质量与用户容忍度 ----

之前看过不少人讨论到底需不需要测试人员；我想说测试人员N年后不管是被重视了还是被淘汰了“测试的行为”永远不会消失；因为没有质量的产品基本上等于没有价值（也就是说没存在的意义），至于对产品质量的要求是由用户容忍度决定的。

Facebook 没有测试人员！但是测试行为一直都在。开发找需求，开发、自测、发布，获得用户反馈，决定功能下线还是上新的功能—相当于一条龙的服务。因为用户的容忍度允许他这么做。

微软不能这么干，修复一个 Windows 的 bug 成本很高，而且用户是花钱买的，也许用户是用来创造价值的（办室、存储、管理），也许一个文件丢失，系统崩溃会给用户带来巨大损失；所以，微软需要很多的测试员。

拿修复成本与用户容忍度做标准，Web 产品优于客户端产品；在 Web 产品中也要分行业；用户对银行系统、火车票、购物网站的容忍度显然要低一些，反过来说也就是对产品的质量要求更高，因为与钱挂钩。就算同一个产品，会员与免费用户的容忍度也是不一样的；因为会员用户有权得到更好质量与服务。

所以，关注分析用户的容忍度的测试才不会把自己变得格格不入。

#### 提升自己的贡献 ----

前面的东西貌似都在“弱化”测试存在的价值；俺本来就不被重视，所以俺就需要更加认真和努力找问题来提升自己存在的价值，你现在说，有些产品不需要太指着的去测试；那你说俺还能干啥？

当我们把测试看成是为开发和产品服务时，也许情况会完全不一样。我们可以提供哪些服务？

用测试发现产品的不可以测试性

前面已经提到队团不管是否有测试人员，但测试行为一定会存在；如果一个产品都不可测试，如何去发现并修复bug ，如何去维护与扩展？尤其对于web产品来讲，不可维护与扩展的产品无疑是致命的。（可以通过项目重构再解决）

建立产品质量的评估方法

为项目团队提供每个版本的bug趋势分析数据，让项目中的每个人都了解项目当前的状态

通过分析bug数据来建立或完善各种 Checklist，帮助项目团队更好的完成需求评审、设计评审以及代码评审，减少bug出现的机会。同时，可以定期将多个项目的Checklist进行合并，使单个项目的经验可以通过Test Team快速的流动起来，及时的作用于其他项目

主动为Architect Team提供每个项目的性能测试数据，帮助他们获取更多的实际项目信息，减少踏入“陷阱”的几率

建立可持续运行的测试框架

建立自动化测试测试框架；构建持续集成，使版本的迭代与更新得到快速的反馈。

建立关注开发质量的开发文化

没有测试人员自测节省人力的了，尤其在单元测试层面。产品的质量应该由开发与测试共同承担。（现实中的责任到人，让团队很难形成这种文化）

原始封面

（九）创建 Docker 镜像

Mon, 22 Jan 2018 14:30:11 +0800

创建镜像有很多方法，用户可以从 Docker Hub 获取已有镜像并更新，也可以利用本地文件系统创建一个。

修改已有的镜像

查看已有的镜像：

$ sudo docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu latest 2a4cca5ac898 9 days ago 111MB

下面进入到ubuntu容器中:

$ sudo docker run -t -i ubuntu /bin/bash
root@543a324ea841:/#

注意： 记住容器的 ID，稍后还会用到。

在容器中添加添加 Python3 开发环境。

root@543a324ea841:/# apt update // 更新软件源

root@543a324ea841:/# apt install python3 // 安装 python3

root@543a324ea841:/# exit // 退出 Ubuntu 容器
exit

当结束后，我们使用 exit 来退出，现在我们的容器已经被我们改变了，使用 docker commit 命令来提交更新后的副本。

$ sudo docker commit -m "Add python3" -a "Docker Newbee" 543a324ea841 ubuntu

sha256:7c0cf1cc5ef36a86252e94eea39c645f53be7dfda87bdcded6d2999917190ffd

-m 来指定提交的说明信息，跟我们使用的版本控制工具一样；

selenium爬虫

Mon, 11 Dec 2017 02:52:34 +0800

why

从上一节的反爬虫建议来看，降低访问频率和将爬虫伪装成真实的用户访问可以对抗大部分的反爬虫策略。

因为selenium是完全操作真实的浏览器，所以发爬虫策略比较难察觉异常，对于一些反爬虫策略非常严酷的网站，用selenium爬虫有时候会起到意想不到的效果。

但是selenium爬虫也有一些局限性，比如效率低下等。

需求

我们使用selenium爬虫来获取知乎今日最热的问题列表。跟之前的知乎爬虫差不多。

搭建开发环境

我们需要使用selenium和chrome driver，具体的安装方式请参考这里

代码

在这里我们就不分析html代码了，打开页面用开发者工具可以看到，今日最热的内容实际上就是找到data-type="daily"的div下，所有的class=question_link的a元素。

# se_zhihu.py

from selenium import webdriver

url = 'https://www.zhihu.com/explore'
dr = webdriver.Chrome()
dr.get(url)

daily_div = dr.find_element_by_css_selector('div[data-type="daily"]')

for link in daily_div.find_elements_by_css_selector('.question_link'):
 print(link.text)

dr.quit()

运行

命令行中直接运行

python se_zhihu.py

结果

由于动态内容的关系，结果可能不尽相同。

如何看待美税改通过后各大公司的发福利提最低工资追加投资等行为？


全球变暖是必然吗？


主播进行游戏直播并从中获得打赏盈利涉及侵犯版权吗？


如何看待张召忠（局座）于12月22日在b站的《荒野行动》直播？


影史上有哪些经典的即兴表演镜头？

我们可以学到什么

selenium操作浏览器可以实现一些爬虫行为
selenium爬虫的效率很低
可以使用headless(无界面的浏览器)来提升selenium爬虫的效率
如果你对selenium的api不熟悉，可以直接使用Puppeteer来做爬虫，详情请看这篇文章

原始封面

（九）TestNG 用例参数化

Sat, 25 Nov 2017 12:20:11 +0800

参数化也测试用例中常用的技巧之一，它可以增加用例的可配置性和减少相同用例的编写。

通过 @Parameters 实现参数化

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;

public class DataProviderTest {

 @Test
 @Parameters({"add1","add2","result"})
 public void testAdd1(int add1, int add2, int result){
 assertEquals(add1+ add2, result);
 }

}

@Parameters 获取参数化数据，作为 testAdd1() 测试方法的参数。

具体的测试数据在 testng.mxl 文件中设置。

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="测试套件">
 <test name="简单测试">
 <parameter name="add1" value="3"/>
 <parameter name="add2" value="2"/>
 <parameter name="result" value="5"/>
 <classes>
 <class name="test.sample.DataProviderTest" />
 </classes>
 </test>
</suite>

<parameter.../> 定义测试数据
name 定义数据的名字，在测试用例中通过该名字来获取对应的vlaue。
value 定义测试数据，通过对应的name来获取该值。

通过 @DataProvider 实现参数化

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;

public class DataProviderTest {

 // 定义对象数组
 @DataProvider(name = "add")
 public Object[][] Users() {
 return new Object[][] {
 { 3, 2, 5 },
 { 2, 2, 4 },
 { 3, 3, 7 },
 };
 }

 @Test(dataProvider="add")
 public void testAdd2(int add1, int add2, int result){
 assertEquals(add1+add2, result);
 }

}

@DataProvider 定义对象数组，数组的名称为：add 。

在 testAdd2() 中通过 dataProvider="add" 调用定义的对象数组，并通过参数获取相应的测试数据。

requests如何查看响应内容?

Wed, 22 Nov 2017 03:23:57 +0800

text 方法会拿到请求的响应内容，比如以再github的timeline接口为例

>>> import requests

>>> r = requests.get('https://api.github.com/events')
>>> r.text
u'[{"repository":{"open_issues":0,"url":"https://github.com/...

Requests会自动去解码server端返回的内容，大部分的unicode字符集都会被无缝解码。

当你发送请求的时候，Requests会根据HTTP headers来推断编码，并在r.text调用的时候使用。我们可以查看和修改Requests的编码，比如

>>> r.encoding
'utf-8'
>>> r.encoding = 'ISO-8859-1'

原始封面

（九）JUnit5 介绍与安装

Mon, 13 Nov 2017 12:25:11 +0800

官方网址：http://junit.org/junit5/

Junit5 已经不算是新的版本了，2016 年推出非正式版，相比较 JUnit4 安装和使用都有一定的差异。

JUnit5 介绍

The new major version of the programmer-friendly testing framework for Java 8

一个新的重要版本，程序员更友的测试框架，基于 Java8。

关于

JUnit5 是 JUnit 的下一代。我们的目标是为 JVM 上的开发人员端测试创建一个最新的基础。这包括针对 Java 8 及以上，以及使许多不同风格的测试。

Junit5 组成

先看来个公式：

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

这看上去比 Junit4 复杂，实际上在导入包时也会复杂一些。

JUnit Platform 是在JVM上启动测试框架的基础。
JUnit Jupiter 是JUnit5扩展的新的编程模型和扩展模型，用来编写测试用例。Jupiter子项目为在平台上运行Jupiter的测试提供了一个TestEngine （测试引擎）。
JUnit Vintage 提供了一个在平台上运行 JUnit3 和 JUnit4 的 TestEngine 。

Maven 安装

首先，你需要通过 IntelliJ IDEA 创建一个 Maven 项目，IntelliJ IDEA 集成的有 Maven，所以，你很容易做到这一点。通过 Maven 的 pom.xml 文件，添加 Junit5 。

9. 读取文件

Mon, 30 Oct 2017 08:17:22 +0800

背景

这一节里我们来学习如何使用python来读取文本文件中的内容。

我们将实现一个简单的读取测试用例文件的脚本，脚本运行时候接收1个参数，用来指定需要读取的用例文件。

创建用例文件

新建名为case001.txt的文本文件，内容如下:

用例编号: itest001
用例名称: 登录成功
测试数据: 用户名:example;密码:example
测试步骤: 略
测试断言: 应该可以正确跳转到www.itest.info

代码实现

新建名为read_case.py，内容如下

from sys import argv

script, file_path = argv

print(f"读取文件: {file_path}")
print()
file_obj = open(file_path)
print(file_obj.read())
file_obj.close()

运行

在命令行中使用下面的命令去执行代码

$python read_case.py case001.txt

注意：请确保先创建了用例文件case001.txt

注意：请确保用例文件case001.txt跟脚本文件read_case.py在同一个文件目录下

注意：我们在脚本名称后面加上了case001.txt，这就是我们指定的用例文件名称，千万不要忘记传入这个参数，否则代码将会报如下的错误

Traceback (most recent call last):
 File "read_case.py", line 3, in <module>
 script, file_path = argv
ValueError: not enough values to unpack (expected 2, got 1)

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

读取文件: case001.txt

用例编号: itest001
用例名称: 登录成功
测试数据: 用户名:example;密码:example
测试步骤: 略
测试断言: 应该可以正确跳转到www.itest.info

常见问题

file_obj = open(file_path) 这一行中，file_obj究竟是什么？

9.使用fixture参数化接口入参

Thu, 26 Oct 2017 07:22:42 +0800

背景

接上一节v2ex网站的查看论坛节点信息的api。具体如下:

节点信息

获得指定节点的名字，简介，URL 及头像图片的地址。

https://www.v2ex.com/api/nodes/show.json

Method: GET
Authentication: None
接受参数：

name: 节点名（V2EX 的节点名全是半角英文或者数字）
例如：

https://www.v2ex.com/api/nodes/show.json?name=python

我们试一下，通过传入不同的name，我们可以获取不同的节点信息。上面例子里我们获取了python讨论区的信息。现在我们把name改成java，该接口会返回java讨论区节点的信息，如下所示

https://www.v2ex.com/api/nodes/show.json?name=python

{
 "id" : 63,
 "name" : "java",
 "url" : "http://www.v2ex.com/go/java",
 "title" : "Java",
 "title_alternative" : "Java",
 "topics" : 1219,
 "stars" : 1547,

 "header" : "The most popular programming language.",


 "footer" : null,

 "created" : 1272669207,
 "avatar_mini" : "//v2ex.assets.uxengine.net/navatar/03af/dbd6/63_mini.png?m=1509589840",
 "avatar_normal" : "//v2ex.assets.uxengine.net/navatar/03af/dbd6/63_normal.png?m=1509589840",
 "avatar_large" : "//v2ex.assets.uxengine.net/navatar/03af/dbd6/63_large.png?m=1509589840"
}

那么新的需求来了，现在我们要测试给定的几个节点名称(python/java/go/nodejs)，v2ex的节点api可以正确返回节点的名字

需求分析

根据3A原则，我们可以设计如下的用例

测试数据: 节点的名称:python/java/go/nodejs
接口地址: https://www.v2ex.com/api/nodes/show.json
断言: 返回的结果里，name字段的值必须等于传入的节点名称

代码

在v2ex_api_test.py的文件中添加如下内容

（九）Locust 参数化

Mon, 16 Oct 2017 07:00:11 +0800

使用 LoadRunner 和 JMeter 的同学都知道，性能测试工具设置参数化颇为麻烦，但对于 Python 来说，生成点数据再简单不过了。

参数化系统登录

这里以某系统登录为例，简单介绍登录用户名密码的参数化实现

from locust import HttpLocust, TaskSet, task
from random import randint

# Web性能测试
class UserBehavior(TaskSet):

 def on_start(self):
 self.login()

 # 随机返回登录用户
 def login_user():
 users = {"user1":123456,"user2":123123,"user3":111222}
 data = randint(1, 3)
 username = "user"+str(data)
 password = users[username]
 return username, password

 @task
 def login(self):
 username, password = login_user()
 self.client.post("/login_action", {"username":username, "password":password})


class User(HttpLocust):
 task_set = UserTask
 min_wait = 1000
 max_wait = 3000
 host = "http://www.xxx.com"

创建 login_user() 方法，定义登录字典 users , 通过randint 随机获取字典中的用户数据。

在 login() 登录任务中，调用 login_user() 方法实现随机用户的登录。

关于参数化方式很多，这里起一个抛砖引玉作用。

关于 Locust 工具就介绍到这里，能否把 Locust 在工作中用好，取决于你对性能测试业务的理解，其次是灵活的运行 python 语言。

原始封面

09. UI 界面（新用户必看）

Mon, 16 Oct 2017 04:00:11 +0800

IntelliJ IDEA 界面介绍

首次打开

重点说明： IntelliJ IDEA 是没有类似 Eclipse 的工作空间的概念（Workspaces ），最大单元就是 Project。如果你同时观察多个项目的情况，IntelliJ IDEA 提供的解决方案是打开多个项目实例，你可以理解为开多个项目窗口。

命令 Create New Project 创建一个新项目。

命令 Import Project 导入一个已有项目。

命令 Open 打开一个已有项目，可以直接打开 Eclipse 项目，但是由于两者 IDE 下的项目配置不一样，所以项目还是需要配置的。

命令 Check out from Version Control 可以通过服务器上的项目地址 Checkout Github 上面项目或是其他 Git 托管服务器上的项目。

为了介绍 IntelliJ IDEA 界面，我们这里创建一个新 HTML 项目。

新建 HTML 项目

appium新手入门（9）—— appium API 之应用操作

Thu, 07 Sep 2017 10:24:12 +0800

本小节的所罗列的方法主要针对应用的操作，如应用的安装、卸载、关闭、启动等。

1、安装应用

方法：

installApp()

安装应用到设备中去。需要apk包的路径。

driver.installApp("path/to/my.apk");
driver.installApp("D:\\android\\apk\\ContactManager.apk");

2、卸载应用

方法：

removeApp()

从设备中删除一个应用。

driver.removeApp("com.example.android.apis");

3、关闭应用

方法：

closeApp()

关闭打开的应用，默认关闭当前打开的应用，所以不需要入参。这个方法并非真正的关闭应用，相当于按home键将应用置于后台，可以通过launchApp()再次启动。

4、启动应用

方法：

launchApp()

启动应用。你一定很迷惑，不是在初始化的配置信息已经指定了应用，脚本运行的时候就需要启动应用，为什么还要有这个方法去启动应用呢？重新启动应用也是一个测试点，该方法需要配合closeApp()使用的。

driver.closeApp();
driver.launchApp();

5、检查应用是否安装

方法：

isAppInstalled()

检查应用是否已经安装。需要传参应用包的名字。返回结果为Ture或False。

driver.isAppInstalled('com.example.android.apis');

6、将应用置于后台

方法：

runAppInBackground()

将当前活跃的应用程序发送到后台。这个方法需要入参，需要指定应用置于后台的时长。

driver.runAppInBackground(2);

7、应用重置

方法：

resetApp()

重置当前被测程序到出始化状态。该方法不需要入参。

driver.resetApp();

原始封面

JMeter官方文档：9. 构建 WebService 测试计划

Thu, 24 Aug 2017 09:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

9. 构建 WebService 测试计划

在本章节，你将学习如何创建一个测试计划去测试 WebService。先创建5个用户请求同一个页面，同时每个请求重复2次，因此总数为（5个用户）X（1次请求）X（重复请求）= 10 次 HTTP 请求。构建测试计划过程中，会使用到以下几个元素：线程组、HTTP 请求、聚合报告

如果采样器使用Web服务时出现错误，请仔细检查 SOAP 消息，并确保格式正确。特别要确保 xmlns 属性与WSDL完全相同。如果xml命名空间不同，则 webservice 可能会返回错误。

9.1 构建 WebService 测试计划

在测试计划中，将会用到 .NET 语言写的web服务，在此就不详细介绍web 服务的编写方法了。如果不会，请自行谷歌 web 服务并尝试用 java 或 .NET熟练起来。必须强调的是，使用 .NET 和 Java 实现 web 服务是有较大差别。该主题太广泛无法写到用户手册里，所以想了解具体差异可参考其他资料。

Jmeter是按照树状的排列方式去发送请求的

找到菜单中的 文件 → Templates , Select Template 中的 “Building a SOAP Webservice Test Plan”，点击 “Creat” 按钮。

图9.1.0 WebService 模版

9.什么是mock server

Tue, 22 Aug 2017 04:41:43 +0800

使用场景

前端客户端团队和后端服务端团队往往节奏是不一致的。前端很多情况下需要等待后台的api开发完成后才能进行开发联调和测试，这种前后端不对称就造成了前后端团队节奏不一致，从而造成整个项目/产品交付/发布延期。

有一种解决方案的思路是前后端先约定好后端提供的api接口的细节，前端人员自行先模拟出这些后端的实现，当然这些实现是假的，不过前端可以去调用这些假的实现，而且能拿到返回，这样一来前端就不需要等待后端开发完成才开始工作了。

但是这样还是会有问题，前端实现的假的api没办法迅速反映出后端的变化。简单来说就是后端可能在约定好的api接口上进行了些许修改，而没有知会前端人员，这样前端的假的api实现并没有相应更新，在正式联调时就会出现问题。

像这种假的api实现，不管是前端实现的还是后端去实现的，我们可以称之为mock server。

mock表示这个api返回的数据是假的，仅作为测试用的
server表示需要启动服务，说到底这是一个服务程序

契约测试

由于前后端往往有一些信息不对称，导致约定的api可能在前后端都会发生变化，所以保证前后端的一致性就成了一个挑战。

这时候有人提出了契约测试，大致思想是前后端共用一份契约，约定了api的细节，前后端的任何变化都需要先修改契约，然后通过契约去通知前后端团队，统一更新实现。这也是契约精神的表现。

如果为契约测试设置一种测试工具的话，我会规划下面一些特性

契约的描述工具：也就是契约长什么样子，用什么工具去定义才能让前后端团队秒懂
通过契约自动生成mock server实现，这样前端团队就可以拿来即用了，如果契约修改了，那么前端团队也很容易感知到
通过契约自动生成接口测试用例，这样通过持续运行这些接口测试用例，后端团队就可以第一时间发现契约的修改

原始封面

appium简明教程（9）——如何获取android app的Activity

Sat, 12 Aug 2017 08:11:31 +0800

有时候在appium的Desired Capabilities中需要指定被测app的appActivity，下面的方法可能会对你有所帮助。

方法一

如有你有待测项目的源码，那么直接查看源码就好。如果没有，那么请联系有源码的同学，这是推荐方法。

方法二

如果你没有代码，那么可以反编译该app。

这里将用到2个工具，分别是dex2jar和jd-gui。你可以在这里下载目前为止的最新版本以及示例apk。

我们以工具包里的ContactManager.apk为例，简单介绍一下反编译的流程。

1，重命名ContactManager.apk为ContactManager.zip并解压得到文件classes.dex；
2，解压dex2jar-0.0.9.15.zip，并从命令行进入该文件夹；
3，运行命令

d2j-dex2jar.bat path_to\classes.dex
在当前文件夹下得到classes-dex2jar.jar；

4，解压jd-gui-0.3.6.windows.zip得到文件jd-gui.exe；
5，使用jd-gui.exe打开classes-dex2jar.jar；

嗯，好了，可以尽情欣赏了。上图。

上图所示的ContactManager就是待测app的main activity。

方法三

参考testerhome的这个帖子

使用log查看大法(嗯，windows上没grep不幸福，好在有powershell的Select-String，可以拿来勉强一用)，直接搬砖。

a、启动待测apk
b、开启日志输出：adb logcat>D:/log.txt
c、关闭日志输出：ctrl+c
d、查看日志

找寻：

Displayed com.mm.android.hsy/.ui.LoginActivity: +3s859ms
appPackage = com.mm.android.hsy
appActivity = .ui.LoginActivity

好了，准备活动做的差不多了。下一节乙醇带大家进行控件定位之旅。

原始封面

性能测试流程（四）——测试工具选型

Fri, 11 Aug 2017 05:59:11 +0800

根据对系统性能测试点的分析，我们选择合适的工作。不是所有的性能需求都要用LoadRunner或Jmeter来进行的。只要能满足需求就可以了，我个人倾向于轻量级的性能工具，或自己动手写代码。

测试工具的比较：

软件性能测试工具分为三类，商业收费工具、开源免费工具、自主开发工具。

表：

–	商业工具	开源工具	自研工具
优点	功能强大且简单易用；提供丰富的功能，支持更多协议和并发用户数，丰富的计数器和测试结果；自动生成脚本，学习成本较低；很强的稳定性和可靠性。	轻量灵活容易扩展；可免费下载使用，可查看工具源代码，根须需求容易扩展。	贴近需求，开发出更适合需求的工具，较开源工具学习成本低。可形成特有的工具体系。
缺点	依赖工具本身提供的功能，较难扩展。工具体积大，购买成本高。	学习成本高，不能完全满足性能测试需求，需要功能扩展。功能相对比较简陋。	工具开发成本高，需要专业的工具开发人员或团队，工具成本也会存在不确定。

通过上面的比较分析，很难判别对某类工具的取舍，各自有其明显的优势，当然也有明显的缺点，如何更好选择工具，这里就要结合实际性能的需求了。

需要考虑以下几个方面:

性能需求：

首先要考虑的是否满足性能需求，例如系统的协议不支持，无法创建脚本，系统的模拟用户数达不到，或都某此特殊功能无法测试，如流媒体性能测试等。一些有性能工具是无法满足这些需求的，那当然要首先排除。

购买成本

对于商业工具的购买成本也是我们需要考虑的问题，其实，这个问题也是老板需要考虑的问题，对性能测试成本的整体预算等。当然了，在满足性能需求的前提下，当然一切从简。正版LoadRunner的服务费用非常的高。那么开源软件呢？开源的性能测试工具其实非常的多，因为它们都分别适合在不同的需求场景下，所以，它们的体积相比商业软件会小很大，当然功能也相对简陋。但是他们在某些情况下可以完全满足某些性能需求，或者可以通过几款开源工具配合满足，或者通过对开源工具进行扩展进行满足。对开源工具进行扩展，对测试人员的要求较高。需要测试人员对工具的原理及源代码有相当有研究。这里对测试人员自动能力的提升非常有帮助。或者你的性能测试项目特殊，找遍市面上的所有性能工具无一款满意，商业定制成本过高。或者你想构建自己有工具体系。处于公司需求的特殊性与长期性考虑，可以自主开发一个性能测试工具来用。一次开发，永久收益（当然也需要维护与升级、扩展等），而且更贴近自已的需求。目前很多知名的大公司都有自己的性能测试工具，用于内部使用。

人员学习成本：

最后要提到的就是人员对工具的学习成本，其实，测试人员在选择性能测试工具时最先考虑的就是从自己会使用的工具入手，这样可以最低的控制学习成生，如果整一个工具，测试人员单学测试脚本就学了半年，老板早让你走人了。这也是对性能测试人员要求较高的地方。所以，对于性能测试人员，你最好熟悉一款流程的商业性能工具，一款开源免费性能具，还需要熟悉常见的性能脚本开发语言等，这是基本要求。

原始封面

（九）通过xpath去定位页面上的元素

Sat, 05 Aug 2017 02:49:18 +0800

xpath教程

自学xpath

xpath语法要点

nodename 选取此节点的所有子节点。
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。

示例代码

// <input id="input__text2" type="number" placeholder="Enter a Number">
dr.findElement(By.xpath('//input[@type="number"]')).sendKeys('66666');

总结

css和xpath选择器大家只需要精通其中一种就可以了。

原始封面

（九）软件测试人员定位

Thu, 20 Jul 2017 07:59:11 +0800

工作已将近三年了，虽然这三个年头里我都在积极的学习着与测试相关的技术；但是能沉淀的东西很少。相信测试同学都有类似的感觉。

不要为了测试而测试

当然了，如果你办的是“中国音乐家钢琴协会”，你有责任要求会员达到国际超一流水平，为国家和个人赢得荣誉。

为贡献产品的发展测试远比为了测试了测试所带来的价值大得多；所以站在产品的发展上去看待测试工作更能体现自己的价值。

记得去年的总结自己对测试流程的理解。随着工作年龄的加长对这些问题也有进一步的看法；所以，再拿来炒一炒，希望能炒出新的味道。

没有最好的开发测试流程，只有最适合项目的开发测试的流程；

为什么会这样？因为这个产品属于前期开发阶段，很多功能还没上线。整个团队都在贡献着产品的发展；需要快速的将需求转化成功能给用户使用。

所以，没有最好的开发测试流程，只有最适合项目与阶段的开发测试的流程。

#### 产品质量与用户容忍度 ----

所以，关注分析用户的容忍度的测试才不会把自己变得格格不入。

#### 提升自己的贡献 ----

当我们把测试看成是为开发和产品服务时，也许情况会完全不一样。我们可以提供哪些服务？

用测试发现产品的不可以测试性

建立产品质量的评估方法

为项目团队提供每个版本的bug趋势分析数据，让项目中的每个人都了解项目当前的状态

主动为Architect Team提供每个项目的性能测试数据，帮助他们获取更多的实际项目信息，减少踏入“陷阱”的几率

建立可持续运行的测试框架

建立自动化测试测试框架；构建持续集成，使版本的迭代与更新得到快速的反馈。

建立关注开发质量的开发文化

没有测试人员自测节省人力的了，尤其在单元测试层面。产品的质量应该由开发与测试共同承担。（现实中的责任到人，让团队很难形成这种文化）

贡献产品发展

旧病成医，测试的产品多了自然会对产品有自己的理解，产品的定位，用户习惯与体验；可以从测试的角度贡献产品的发展。（这个由产品的特点，公司文化决定）

原始封面

（九）模拟键盘操作

Sat, 01 Jul 2017 07:37:11 +0800

Keys()类提供了键盘上几乎所有按键的方法。前面了解到， sendKeys()方法可以用来模拟键盘输入，除此之外，我们还可以用它来输入键盘上的按键，甚至是组合键，如 Ctrl+A、 Ctrl+C 等。

import org.openqa.selenium.WebElement;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;

public class Keyboard {

 public static void main(String[] args)throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 WebElement input = driver.findElement(By.id("kw"));

 //输入框输入内容
 input.sendKeys("seleniumm");
 Thread.sleep(2000);

 //删除多输入的一个 m
 input.sendKeys(Keys.BACK_SPACE);
 Thread.sleep(2000);

 //输入空格键+“教程”
 input.sendKeys(Keys.SPACE);
 input.sendKeys("教程");
 Thread.sleep(2000);

 //ctrl+a 全选输入框内容
 input.sendKeys(Keys.CONTROL,"a");
 Thread.sleep(2000);

 //ctrl+x 剪切输入框内容
 input.sendKeys(Keys.CONTROL,"x");
 Thread.sleep(2000);

 //ctrl+v 粘贴内容到输入框
 input.sendKeys(Keys.CONTROL,"v");
 Thread.sleep(2000);

 //通过回车键盘来代替点击操作
 input.sendKeys(Keys.ENTER);
 Thread.sleep(2000);

 driver.quit();
 }
}

需要说明的是，上面的脚本没有什么实际意义，但向我们展示了模拟键盘各种按键与组合键的用法。

（九）设置元素等待

Thu, 22 Jun 2017 12:59:11 +0800

WebDriver提供了两种类型的等待：__显式等待__和__隐式等待__。

显式等待

显式等待使WebdDriver等待某个条件成立时继续执行，否则在达到最大时长时抛出超时异常（TimeoutException）。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Firefox()
driver.get("http://www.baidu.com")

element = WebDriverWait(driver, 5, 0.5).until(
 EC.presence_of_element_located((By.ID, "kw"))
 )
element.send_keys('selenium')
driver.quit()

WebDriverWait类是由WebDirver 提供的等待方法。在设置时间内，默认每隔一段时间检测一次当前页面元素是否存在，如果超过设置时间检测不到则抛出异常。具体格式如下：

WebDriverWait(driver, timeout, poll_frequency=0.5, ignored_exceptions=None)

driver ：浏览器驱动。
timeout ：最长超时时间，默认以秒为单位。
poll_frequency ：检测的间隔（步长）时间，默认为0.5S。
ignored_exceptions ：超时后的异常信息，默认情况下抛NoSuchElementException异常。

WebDriverWait()一般由until()或until_not()方法配合使用，下面是until()和until_not()方法的说明。

until(method, message=‘’) 调用该方法提供的驱动程序作为一个参数，直到返回值为True。
until_not(method, message=‘’) 调用该方法提供的驱动程序作为一个参数，直到返回值为False。

在本例中，通过as关键字将expected_conditions 重命名为EC，并调用presence_of_element_located()方法判断元素是否存在。

隐式等待

WebDriver提供了implicitly_wait()方法来实现隐式等待，默认设置为0。它的用法相对来说要简单得多。

from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from time import ctime

driver = webdriver.Firefox()

# 设置隐式等待为10秒
driver.implicitly_wait(10)
driver.get("http://www.baidu.com")

try:
 print(ctime())
 driver.find_element_by_id("kw22").send_keys('selenium')
except NoSuchElementException as e:
 print(e)
finally:
 print(ctime())
 driver.quit()

implicitly_wait()默认参数的单位为秒，本例中设置等待时长为10秒。首先这10秒并非一个固定的等待时间，它并不影响脚本的执行速度。其次，它并不针对页面上的某一元素进行等待。当脚本执行到某个元素定位时，如果元素可以定位，则继续执行；如果元素定位不到，则它将以轮询的方式不断地判断元素是否被定位到。假设在第6秒定位到了元素则继续执行，若直到超出设置时长（10秒）还没有定位到元素，则抛出异常。

原始封面

（十）Docker Compose安装与创建Flask web应用

Mon, 22 Jan 2018 14:25:11 +0800

Docker Compose 是 Docker 官方编排（Orchestration）项目之一，负责快速在集群中部署分布式应用。

Dockerfile 可以让用户管理一个单独的应用容器；而 Compose 则允许用户在一个模板（YAML 格式）中定义一组相关联的应用容器（被称为一个 project，即项目），例如一个Web服务容器再加上后端的数据库服务容器等。

安装

该项目由 Python 编写，实际上调用了 Docker 提供的 API 来实现。通过pip安装。

$ python3 -m pip install docker-compose

安装成功后，可以查看docker-compose命令的用法。

$ docker-compose
Define and run multi-container applications with Docker.

Usage:
 docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
 docker-compose -h|--help

Options:
 -f, --file FILE Specify an alternate compose file (default: docker-compose.yml)
 -p, --project-name NAME Specify an alternate project name (default: directory name)
 --verbose Show more output
 --no-ansi Do not print ANSI control characters
 -v, --version Print version and exit
 -H, --host HOST Daemon socket to connect to

 ……

创建 Flask 应用

创建使用Flask web应用，并将数值记入Redis。

（十） TestNG 多线程运行用例

Sat, 25 Nov 2017 12:15:11 +0800

TestNG 是我接触过的唯一自身支持多程技术的单元测试框架。虽然代码级别的单元测试运行得很快，多线程的意义并不大。但如果是UI自动化测试的话运行速度就会非常慢，这个时候多线程技术就会变得很重要。

多线程配置

这里只介绍 testng.xml 文件，其中的使用到的测试用例，请参考前面的章节创建。

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="测试套件" parallel="classes" thread-count="2" >
 <test name="简单测试">
 <classes>
 <class name="test.sample.FirstTest" />
 <class name="test.sample.SecondTest" />
 </classes>
 </test>
</suite>

parallel 设置多线程的级别划分。
parallel=“methods”: TestNG将在不同的线程中运行所有的测试方法。依赖方法也将在单独的线程中运行，但它们将尊重你指定的顺序。
parallel=“tests”: TestNG 将在同一个线程中运行相同的标记的所有方法，但是每个标记将在一个单独的线程中。这允许你将所有非线程安全的类分组在同一个中，并保证它们将在同一个线程中运行，同时利用尽可能多的线程来运行测试。
parallel=“classes”: TestNG将在同一个线程中运行同一个类中的所有方法，但是每个类都将在一个单独的线程中运行。
parallel=“instances”: TestNG将在同一个线程中运行相同实例中的所有方法，但是在两个不同实例上的两个方法将在不同的线程中运行。
thread-count 用于指定线程的个数。

原始封面

requests中如何查看响应的headers?

Wed, 22 Nov 2017 03:23:57 +0800

r.headers 可以拿到Python 字典形式展示的服务器响应头：

>>> r.headers
{
 'content-encoding': 'gzip',
 'transfer-encoding': 'chunked',
 'connection': 'close',
 'server': 'nginx/1.0.4',
 'x-runtime': '148ms',
 'etag': '"e1ca502697e5c9317743dc078f67693f"',
 'content-type': 'application/json'
}

但是这个字典比较特殊：它是仅为 HTTP 头部而生的。根据RFC 2616， HTTP 头部是大小写不敏感的。

因此，我们可以使用任意大写形式来访问这些响应头字段：

>>> r.headers['Content-Type']
'application/json'

>>> r.headers.get('content-type')
'application/json'

原始封面

（十）JUnit5 创建测试

Mon, 13 Nov 2017 12:25:11 +0800

创建测试用例

我在 IntelliJ IDEA 中创建的 Maven 项目，目录结构如下：

在 test.java 目录下创建一个 FistJUnit5Tests 类。代码如下：

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

class FirstJUnit5Tests {

 @Test
 void myFirstTest() {
 assertEquals(2, 1 + 1);
 }

}

明显看出和 Junit4 还是有些不同的。

首先，导入测试测试注解（@Test）和断言方法（assertEquals）的路径不同。

其次，不需要手动把测试和测试方法声明为 public 了。

原始封面

10.使用fixture参数化测试预期结果

Wed, 25 Oct 2017 07:22:42 +0800

背景

接上一节v2ex网站的查看论坛节点信息的api。

我们在上一节的测试用例里只断言了返回值的name字段必须与我们传入的入参相同，但是返回值的id却没有进行判定。这一节里我们加强一下测试脚本，实现判断id的功能。

测试数据

python, id=90
java, id=63
nodejs, id=436
go, id=375

代码实现

在v2ex_api_test.py的文件中加入如下内容:

class TestV2exApiWithExpectation(object):
 domain = 'https://www.v2ex.com/'

 @pytest.mark.parametrize('name,node_id', [('python', 90), ('java', 63), ('go', 375), ('nodejs', 436)])

 def test_node(self, name, node_id):
 path = 'api/nodes/show.json?name=%s' %(name)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == name
 assert res['id'] == node_id
 assert 0

运行及结果

$ pytest v2ex_api_test.py
======================================================================== test session starts ========================================================================
platform darwin -- Python 2.7.12, pytest-3.2.3, py-1.4.34, pluggy-0.4.0
rootdir: /Users/easonhan/code/testclass.net/src/pytest, inifile:
collected 9 items

v2ex_api_test.py .FFFFFFFF

============================================================================= FAILURES ==============================================================================
______________________________________________________________ TestV2exApiWithParams.test_node[python] ______________________________________________________________

self = <v2ex_api_test.TestV2exApiWithParams object at 0x10618eb10>, lang = 'python'

 def test_node(self, lang):
 path = 'api/nodes/show.json?name=%s' %(lang)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == lang
> assert 0
E assert 0

v2ex_api_test.py:27: AssertionError
_______________________________________________________________ TestV2exApiWithParams.test_node[java] _______________________________________________________________

self = <v2ex_api_test.TestV2exApiWithParams object at 0x106691790>, lang = 'java'

 def test_node(self, lang):
 path = 'api/nodes/show.json?name=%s' %(lang)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == lang
> assert 0
E assert 0

v2ex_api_test.py:27: AssertionError
________________________________________________________________ TestV2exApiWithParams.test_node[go] ________________________________________________________________

self = <v2ex_api_test.TestV2exApiWithParams object at 0x10666dc50>, lang = 'go'

 def test_node(self, lang):
 path = 'api/nodes/show.json?name=%s' %(lang)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == lang
> assert 0
E assert 0

v2ex_api_test.py:27: AssertionError
______________________________________________________________ TestV2exApiWithParams.test_node[nodejs] ______________________________________________________________

self = <v2ex_api_test.TestV2exApiWithParams object at 0x106691890>, lang = 'nodejs'

 def test_node(self, lang):
 path = 'api/nodes/show.json?name=%s' %(lang)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == lang
> assert 0
E assert 0

v2ex_api_test.py:27: AssertionError
__________________________________________________________ TestV2exApiWithExpectation.test_node[python-90] __________________________________________________________

self = <v2ex_api_test.TestV2exApiWithExpectation object at 0x1066d20d0>, name = 'python', node_id = 90

 @pytest.mark.parametrize('name,node_id', [('python', 90), ('java', 63), ('go', 375), ('nodejs', 436)])

 def test_node(self, name, node_id):
 path = 'api/nodes/show.json?name=%s' %(name)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == name
 assert res['id'] == node_id
> assert 0
E assert 0

v2ex_api_test.py:40: AssertionError
___________________________________________________________ TestV2exApiWithExpectation.test_node[java-63] ___________________________________________________________

self = <v2ex_api_test.TestV2exApiWithExpectation object at 0x1066e9690>, name = 'java', node_id = 63

 @pytest.mark.parametrize('name,node_id', [('python', 90), ('java', 63), ('go', 375), ('nodejs', 436)])

 def test_node(self, name, node_id):
 path = 'api/nodes/show.json?name=%s' %(name)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == name
 assert res['id'] == node_id
> assert 0
E assert 0

v2ex_api_test.py:40: AssertionError
___________________________________________________________ TestV2exApiWithExpectation.test_node[go-375] ____________________________________________________________

self = <v2ex_api_test.TestV2exApiWithExpectation object at 0x10666d790>, name = 'go', node_id = 375

 @pytest.mark.parametrize('name,node_id', [('python', 90), ('java', 63), ('go', 375), ('nodejs', 436)])

 def test_node(self, name, node_id):
 path = 'api/nodes/show.json?name=%s' %(name)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == name
 assert res['id'] == node_id
> assert 0
E assert 0

v2ex_api_test.py:40: AssertionError
_________________________________________________________ TestV2exApiWithExpectation.test_node[nodejs-436] __________________________________________________________

self = <v2ex_api_test.TestV2exApiWithExpectation object at 0x1066d2710>, name = 'nodejs', node_id = 436

 @pytest.mark.parametrize('name,node_id', [('python', 90), ('java', 63), ('go', 375), ('nodejs', 436)])

 def test_node(self, name, node_id):
 path = 'api/nodes/show.json?name=%s' %(name)
 url = self.domain + path
 res = requests.get(url).json()
 assert res['name'] == name
 assert res['id'] == node_id
> assert 0
E assert 0

v2ex_api_test.py:40: AssertionError
================================================================ 8 failed, 1 passed in 1.81 seconds =================================================================

原始封面

10. UI 主题、字体、编辑区主题、文件编码修改、乱码问题（新用户必看）

Mon, 16 Oct 2017 03:00:11 +0800

IntelliJ IDEA 主题、字体、编辑区主题、文件编码修改、乱码问题

主题修改

上图标注 1 所示为 IntelliJ IDEA 修改主题的地方，在 Windows 系统上 IntelliJ IDEA 默认提供的主题有四套：Darcula、IntelliJ、Windows、Alloy. IDEA Theme。除了 Darcula 是黑色主题，其他三套都是以白色为背景的。

其他操作系统上不一定会也有四套主题的，主题的选择上大家根据自己喜好即可。改变主题需要重启 IntelliJ IDEA 方可看到效果。

字体修改

主题字体修改

如上图标注 1 所示，IntelliJ IDEA 主题字体的修改要先勾选 Override default fonts by 。默认 IntelliJ IDEA 是不推荐修改的，但是由于字体是有分包含中文和不包含中文之分的，一般使用英文的国家是不需要额外担心乱码问题的，而我们需要。

字体的审美上每个人不一样，但是如上一段说的，这里的字体修改是需要知道一个前提的，那就是你选择的那个字体必须含有中文，比如微软雅黑和宋体这类是包含中文的，而 Courier New 和 Monaco 这类只是单纯的英文字体。

如果你选择的字体不包含中文，那可能会在很多位置上出现类似 口口口口口 这样的乱码问题，比如文件名含有中文、字体是中文名字的都会变成 口口口口口。

在修改 IntelliJ IDEA 的主题字体的时候，不建议把字体调成很大，因为很多人遇到这样一种情况：显示器分辨率低，主题字体又大，在 IntelliJ IDEA 的某些操作的工具菜单、右键菜单选项中部分选项超出了分辨率显示范围，没办法被选中。当然了，如果你一定要把字体改大，又不用大分辨率显示器，那可以通过 IntelliJ IDEA 的 Menus and Toolbars 删除部分你认为用不到的菜单，但是一般不建议这样做。

还需要特别注意的时候，如果你是开着 IntelliJ IDEA 的时候，新装了一个字体的话，那必须重启IntelliJ IDEA 之后才能在下拉列表找到新装的字体。

代码编辑字体修改

appium新手入门（10）—— appium API 之上下文操作

Thu, 07 Sep 2017 10:22:12 +0800

其实上下文的操作主要针对于混合应用。啥是混合应用，简单来说就是APP用里面嵌入网页。Android上的浏览器就属于混合应用。

1、获取当前上下文

方法：

getContext()

获取当前所有的可用的上下文。该方法不需要入参。

String ct = driver.getContext();
System.out.println(ct);

-----------计算器应用的打印结果-----------------------
NATIVE_APP

2、当前所有上下文句柄

方法：

getContextHandles()

获取当前所有可用的上下文。该方法不需要入参。

3、切换上下文

context()

切换到特定的上下文中。需要指定上下文的名称。

driver.context('NATIVE_APP')
driver.context('WEBVIEW_1')

原始封面

JMeter官方文档：10. 创建一个点对点的 JMS 测试计划

Thu, 24 Aug 2017 08:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

10.创建一个点对点的 JMS 测试计划

确保所需的jar文件位于JMeter lib目录中。如果没有，关闭JMeter，复制jar文件并重新启动JMeter。参见详细教程

在本节中，将学习如何创建测试计划来测试JMS点对点消息传递。先设置1个线程组5个线程发送4个请求，通过队列的形式发送。固定的回复队列将用于监听回复消息。要构建测试计划，您将使用以下元素：线程组，JMS点对点和图形结果。

关于 JMS 的一般注意事项：目前有两个JMS采样器。一个是使用 JMS Topic，另一个时使用 Queue。 Topic 通常被称为pub/sub消息。 Topic 消息通常用于生产者发布消息并由多个订阅者接收的情况。 JMS 采样器需要 JMS 实现 jar 文件，比如 Apache ActiveMQ 包。参见这里的 ActiveMQ 提供的 jar 的列表。

10.1 增加一个线程组

首先，对每个要执行的 JMeter 测试计划添加一个线程组。线程组会告诉 JMeter 需要模拟的用户数量，发送请求的频率以及发送请求的数量。

然后，添加 ThreadGroup 元素，首先选择测试计划，单击鼠标右键获取添加菜单，然后选择添加→线程组。

接下来，需要修改默认属性。现在可以在 JMeter 窗口的右侧部分看到线程组控制面板（参见下面的图10.1）

10.使用flask实现mock server

Mon, 21 Aug 2017 04:41:43 +0800

flask

flask是python实现的简单的web框架，与django互补。

flask教程

如何理解flask

路由 -> /request/uri
handler -> 路由进来之后处理request并返回response的逻辑

最简单的例子

from flask import Flask
app = Flask(__name__)

@app.route("/") # 路由
def hello(): # handler
 return "Hello World!"

实现mocked smile task api

获取所有的任务

GET /api/tasks # get all tasks

查看一个任务的详情

GET /api/tastks/:task_id # get a task with task_id

完成一个任务

PUT /api/tastks/:task_id # complete a task

代码


from flask import Flask, jsonify, g
import copy
app = Flask(__name__)

@app.before_request
def set_up_data():
 g.data = [
 {'id': 1, 'title': 'task 1', 'desc': 'this is task 1'},
 {'id': 2, 'title': 'task 2', 'desc': 'this is task 2'},
 {'id': 3, 'title': 'task 3', 'desc': 'this is task 3'},
 {'id': 4, 'title': 'task 4', 'desc': 'this is task 4'},
 {'id': 5, 'title': 'task 5', 'desc': 'this is task 5'}
 ]

 g.task_does_not_exist = {"msg": "task does not exist"}

@app.route('/api/tasks')
def get_all_tasks():
 return jsonify(g.data)

@app.route('/api/tasks/<int:task_id>')
def get_task(task_id):
 if task_id > 0 and task_id <= len(g.data):
 return jsonify(g.data[task_id])
 else:
 return jsonify(g.task_does_not_exist)

@app.route('/api/tasks/<int:task_id>', methods=['PUT'])
def complete_task(task_id):
 if task_id > 0 and task_id <= len(g.data):
 tmp = copy.deepcopy(g.data[task_id])
 tmp['done'] = True
 return jsonify(tmp)
 else:
 return jsonify(g.task_does_not_exist)

运行

set FLASK_APP=smile_task_mock_server.py

flask run
* Serving Flask app "smile_task_mock_server"
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

浏览器打开localhost:5000就好了

appium简明教程（10）——控件定位基础

Fri, 11 Aug 2017 08:40:32 +0800

狭义上讲，UI级的自动化测试就是让机器代替人去点来点去的过程。

但机器去点什么（点上面还是点左边），怎么点（是长按还是轻触），这些东西是必须由代码的编写者所指示清楚的。

控件定位就是解决机器点什么的问题的。

一般说来，我们可以这样告诉机器：去点登陆按钮。

机器很笨，它并不知道什么是登陆按钮。因为登陆按钮是自然语言的描述。

如果你让一个人去点登陆按钮，那么他其实也是要经过一系列的脑补以后才可以做这件事的。

这个脑补的过程还原如下：

这个一定是个按钮

这个按钮一定在被测的应用上

这个按钮大概上面有登陆这个文字信息

嗯，还真有一个，那么点吧。

这就是人探索性测试的一个简单过程。一般来说，如果你给出的信息不太充分，人类还是可以通过一系列的探索性思维去理解你的描述的。这个属于心理学的问题，不展开解释。

但是机器并不是人，如果你给出的描述不精确的话，机器是不会自发性的进行探索和脑补的。

因此控件定位就是精确的描述控件特征并告诉机器的过程。

本文版权归乙醇所有，欢迎转载，但请注明作者与出处，严禁用于任何商业用途

控件的特征就是控件的属性，我们可以通过上一讲中的uiautomatorviewer去获取。

在appium的定位世界里，下面这些方法是可以为我们使用的。也就是说，我们通过下面几个约定好的方式，按照webdriver和appium的DSL（自行搜索并理解）进行控件特征的描述和定位。

继承自webdriver的方法，也就是通过这3个特征可以定位控件

find by “class” (i.e., ui component type，andorid上可以是android.widget.TextView)
find by “xpath” (i.e., an abstract representation of a path to an element, with certain constraints，由于appium的xpath库不完备的原因，这个不太推荐)
find by “id”(android上是控件的resource id)

由Mobile JSON Wire Protocol 协议中定义的方法，更适合移动设备上的控件定位

-ios uiautomation: a string corresponding to a recursive element search using the UIAutomation library (iOS-only)
-android uiautomator: a string corresponding to a recursive element search using the UiAutomator Api (Android-only)
accessibility id: a string corresponding to a recursive element search using the Id/Name that the native Accessibility options utilize.

在appium 的client对Mobile JSON Wire Protocol中定义的方法进行了封装，使其调用起来更加方便

性能测试流程（五）——测试计划

Fri, 11 Aug 2017 04:59:11 +0800

一．简介

简介部分就不用过多描述了，无非项目的背景，进行此次性能测试的原因，以及性能测试覆盖的范围等等，几乎所有项目文档都在开端对项目进行简单的阐述。

二．性能测试需求

寻找的被测试对象和压力点

要测试的对象不是凭空想象出来，而是经过分析与系统数据收集得到。以下取几个典型的压力点。

查询：查询一般比较消耗系统和数据库资源。搜索引擎的查询功能就是典型，如果你在输入框内输入内容，很久就得不到结果。我想被称为“互联网入口”的搜索引擎就不会存在。

交易：对于一些电子商务系统来说，交易过程的性能要求是很高的，如果交易过程消耗用户很长时间的话，用户可能会转投其它平台。当然，除了交易速度外，对交易的成功率要求也是非常高的。不然，造成的损失也是不可估量的。

被测的系统应该是最重要的最基本的功能，也是用户使用最频繁的功能。

三．测试环境

这里的测试环境主要指的软件硬件环境和网络环境。

笔者认为性能测试最好在一个独立的环境内进行，这样不会受到外界的干扰，能够保证测试的数据是独立有效的。如果现你对某个已经上线的网站进行压力测试，那么你得到的数据不是独立的，因为你在做压力测试的时候，其它散户也在访问系统。

软件环境：

这里的软件环境主要指项目运行的环境，比如采用什么样的操作系统、中间件、和数据库。

硬件环境：

这里的硬件环境除了主要包括主机内部部件，cpu、内存、磁盘以及主板、网卡等，传输介质和路由器也应该考虑在内，

网络环境：

网络环境除了考虑测试机与被系统服务器在一个局域网中进行，还应该保证这个网络的独立性。如果在在性能测试的过程中，其它机子也在消耗着路由器资源。那么路由器也会影响到数据库的传输速度。

四．数据准备

在很多时候，我们是要准备测试数据的，例如系统不允许相同用户的重复登录，那么必须要生成合法的用户数据。有时要对系统进行查询测试，只有在系统有一定数据量进才能验证出系统的真实性能。一个数据库中有两条数据和有两千万条数据，同相一条查询操作，对系统造成的压力是完全不一样的。

系统所需数据的分析可以参考以下方式：

历史数据分析有助于数据量级的确定。从历史数据入手，找出高峰期数据量。

从其他相似或者相同系统入手，进行数据分析，找出高峰期数据量。

无历史或者相关系统可以参考的时候，就要对系统的性能数据进行估算，包含系统容量，并发数等数据，估算以后给相关人员进行评审或者修订以后，按照大家同意的性能指标进行测试。

…………

测试数据最好和真实数据相同，如果能够获得真实系统运行3个月的数据，我们就可以在此基础上进行性能测试。

关于数据的生成，我们可以通过工具完成，如数据库数据生成工具，大小文件生成工具等。

五．测试工具

前面已经介绍如何分析需求，需求确定下来之后，我们可以考虑引入什么样的工具适合性能需求。

当然，在引入工具的时候除了考虑可以是否满足需求，还应该考虑工具的成本，这不单指工具的购买成本，还有测试人员对工具的学习成本。

关于测试工具的选择，后面会单独有一章节介绍，这里就不细说了。

如果你选择的性能测试工具不是足够的强大的话，你可能还需要其它的辅助的工具。如果Jmeter利用BadBoy来录制脚本，更能提高脚本开发效率。在压力测试的过程中也可能需要性能计数器来记录软硬件的性能。如监控服务器CPU、内存的计数器，记录中间件日志的监控中工具，监控数据库性能的监控工具等。

六．测试策略

对于一个特定的业务系统，用户一般会分散在一天的各个时间段进行访问。在不同的时间段中，用户使用业务系统的频率不同，而系统的繁忙程度不同。在一些特定的条件下，可能出现短时间内用户集中访问某个业务系统的情况。例如对于公文处理子系统而言，可能就存在短时间内大量用户查看并办理某条公文的情况。在进行性能测试时，应当使用“考虑最坏情况的原则”。也就是应当在用户使用业务系统最频繁、对系统造成最大压力的情况下对系统的功能进行测试，判断各功能和页面是否能够满足性能的要求，系统的响应时间是否过长。

另一方面，系统性能的验证必须做到“覆盖全面”。虽然系统中各个功能的使用频率并不相同，一些功能的使用频率相对于其他功能来说比较低，但是在进行性能测试和优化时，不能忽略这些功能，编制测试用例时也不能仅仅选择最常用功能。例如可能所有的用户都会访问我的通知列表，但是一般只有5%的用户会使用通过系统设置模块查找某个用户的信息；但是在测试时，我们并不能因为查看用户信息功能的使用频率相对较少，而忽略掉这项功能的测试。所以，这里进行系统性能测试时，对于不同业务，用户的访问比例应该做一个合理分配。

在测试策略上，我们还应该考虑，同一个系统在不同硬件环境下的性能表现。从而让系统满足需求的情况下，硬件配置也能达到一个最佳的状态。过份的增加硬件来满足需求也是一种浪费。再说增加硬件设备不是能解决所有性能问题的。

七．人力与时间安排

最后一条，就是要根据项目的进度要求以及规模，来进行人力与时间的安排。对于大型的性能测试，项目前期的需求调研，环境的部署，工具的选购或开发，人员对测试工具的学习与使用，性能测试的后进行，后期数据的分析与调优。都需要人员安排的。有可以需要专业的，系统工程师、数据库工程师、软件开发工程师、网络工程师以及性能测试工程师的共同参与配合完成。不是一个性能测试人员就可以全部搞定的。

原始封面

（十）模拟键盘按键

Fri, 04 Aug 2017 02:49:18 +0800

sendKeys

sendKeys()方法可以用来模拟用户按下键盘，组合键比如ctrl+c等也可以模拟。

目的

学会使用sendKeys方法
学会使用模拟特殊按钮

场景

测试中我们经常会打开一个页面，然后一下往下拉，直到滚动条拉到最底部，这怎么用selenium来实现呢？

其实我们可以用模拟按空格键的方式实现。大家都知道，在页面上一直按空格键，页面就会到达最底部，当然这并不精确，但大多数时候都是管用的。

下面我们就用代码实现打开qq首页，然后模拟按10下空格键，使页面滚动到最最底部。

代码

var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var Key = webdriver.Key;

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get('http://www.qq.com');

// 把页面的body找到，在body上模拟按钮，这是整页面模拟按键事件的小技巧
var body = dr.findElement(By.css("body"));

// 每隔1.5s按一次空格键
// setTimeout在js binding中相当于其他binding中的sleep功能
for (var i = 0; i < 10; i++) {
 setTimeout(function() {
 body.sendKeys(Key.SPACE);
 }, i * 1500);
}

运行结果

页面会缓慢的滚到最底部，如果你的页面滚到中间就停住了，增加滚动次数即可。

原始封面

10. 写文件

Sat, 01 Jul 2017 08:17:22 +0800

背景

这一节里我们来学习如何使用python向文本文件中写入的内容。

我们将实现一个简单的创建测试用例文件的脚本，脚本运行时候接收3个参数，分别是

用例编号
用例名称
断言

这里我们忽略写入测试步骤，这并不表示编写用例时可以忽略测试步骤

代码实现

新建名为write_case.py，内容如下


from sys import argv

script, case_number, case_name, assertion = argv

file_name = 'case002.txt'

print(f"用例编号: {case_number}")
print(f"用例名称: {case_name}")
print(f"断言: {assertion}")

target = open(file_name, 'w')

print("Truncating the file. Goodbye!")

print(f"write file: {file_name}")

target.write(f"用例编号: {case_number}")
target.write("\n")
target.write(f"用例名称: {case_name}")
target.write("\n")
target.write(f"断言: {assertion}")
target.write("\n")
target.close()

运行

在命令行中使用下面的命令去执行代码

$ python write_case.py 002 Get接口测试 接口返回的状态码必须是200

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

用例编号: 002
用例名称: Get接口测试
断言: 接口返回的状态码必须是200
Truncating the file. Goodbye!
write file: case002.txt

这时候当前文件夹会出现case002.txt文件，内容应该如下所示

用例编号: 002
用例名称: Get接口测试
断言: 接口返回的状态码必须是200

关于文件操作

关于文件的操作，请试着自己写代码去调用下面的方法，实践出真知。

（十）获取断言信息

Fri, 30 Jun 2017 07:37:11 +0800

不管是在做功能测试还是自动化测试，最后一步需要拿实际结果与预期进行比较。这个比较的称之为__断言__。

我们通常可以通过获取title 、URL和text等信息进行断言。text方法在前面已经讲过，它用于获取标签对之间的文本信息。

getTitle()：用于获得当前页面的title。
getCurrentUrl() ：用户获得当前页面的URL。
getText() 获取页面文本信息。

下面同样以百度为例，介绍如何获取这些信息。

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;


public class AssertDemo {

 public static void main(String[] args) throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 System.out.println("Search before================");

 //获取当前的 title 和 url
 System.out.printf("title of current page is %s\n", driver.getTitle());
 System.out.printf("url of current page is %s\n", driver.getCurrentUrl());

 //百度搜索
 WebElement search = driver.findElement(By.id("kw"));
 search.sendKeys("Selenium");
 search.sendKeys(Keys.ENTER);
 Thread.sleep(2000);

 System.out.println("Search after================");

 //获取当前的 title 和 url
 System.out.printf("title of current page is %s\n", driver.getTitle());
 System.out.printf("url of current page is %s\n", driver.getCurrentUrl());

 //获取第一条搜索结果的标题
 WebElement result = driver.findElement(By.xpath("//div[@id='content_left']/div/h3/a"));
 System.out.println(result.getText());

 driver.quit();
 }
}

打印结果：

（十）定位一组元素

Wed, 21 Jun 2017 12:59:11 +0800

WebDriver还提供了8种用于定位一组元素的方法。 ```python find_elements_by_id() find_elements_by_name() find_elements_by_class_name() find_elements_by_tag_name() find_elements_by_link_text() find_elements_by_partial_link_text() find_elements_by_xpath() find_elements_by_css_selector() ``` 定位一组元素的方法与定位单个元素的方法类似，唯一的区别是在单词element后面多了一个s表示复数。

接下来通过例子演示定位一组元素的使用：

from selenium import webdriver
from time import sleep

driver = webdriver.Chrome()
driver.get("https://www.baidu.com")

driver.find_element_by_id("kw").send_keys("selenium")
driver.find_element_by_id("su").click()
sleep(1)

# 定位一组元素
texts = driver.find_elements_by_xpath('//div/h3/a')

# 循环遍历出每一条搜索结果的标题
for t in texts:
 print(t.text)

driver.quit()

程序运行结果：

Selenium - Web Browser Automation
官网
功能自动化测试工具——Selenium篇
selenium + python自动化测试环境搭建 - 虫师 - 博客园
selenium是什么?_百度知道
怎样开始用selenium进行自动化测试(个人总结)_百度经验
Selenium_百度百科
selenium_百度翻译
Selenium官网教程_selenium自动化测试实践_Selenium_领测软件测试网
Selenium(浏览器自动化测试框架)_百度百科
自动化基础普及之selenium是啥? - 虫师 - 博客园
python十大主流开源框架 「菜鸟必看」

原始封面

（十一）Docker Compose创建Wordpress应用

Mon, 22 Jan 2018 14:22:11 +0800

wordpress是最常见博客系统，一般部署需要LAMP/WAMP环境，这介绍通过Docker compose对它进行编排和部署。

Docker Hub地址: https://hub.docker.com/_/wordpress/

wordpress 应用部署

1、建立一个应用的目录

$ mkdir wordpress
$ cd wordpress

2、创建 docker-compose.yml

version: '3.1'

services:

 wordpress:
 image: wordpress
 restart: always
 ports:
 - 8081:80
 environment:
 WORDPRESS_DB_PASSWORD: pw123

 mysql:
 image: mysql:5.7
 restart: always
 environment:
 MYSQL_ROOT_PASSWORD: pw123

images 镜像名
restart 指定版本
ports 80为镜像端口，映射的8081为主机端口。
environment 环境配置，例，WORDPRESS_DB_PASSWORD 为wordpress数据库密码。

3、启动应用

docker-compose执行编排脚本，分别制作和抓取web，redis镜像，启动容器。

$ sudo docker-compose up

……

Creating wordpress_mysql_1 ... done
Creating wordpress_wordpress_1 ... done

整个过程会比较漫长。。。

5、访问应用

打开浏览器方位: http://0.0.0.0:5081/

进入wordpress安装配置界面：

（十一）TestNG 其他使用技巧

Sat, 25 Nov 2017 12:10:11 +0800

除了前面介绍的功能外，TestNG 还有一些使用技巧，相对比较简单，这里通过一个例子来演示。

其它使用技巧

import org.testng.annotations.Test;
import static org.testng.AssertJUnit.assertEquals;


public class OtherTest {

 // 该条用例跳过执行
 @Test(enabled = false)
 public void testCase1(){
 assertEquals(2+2, 4);
 }

 // 设定用例超时时间
 @Test(timeOut = 3000)
 public void testCase2() throws InterruptedException {
 Thread.sleep(3001);
 }

 // 预设用例抛出的异常类型
 @Test(expectedExceptions = RuntimeException.class)
 public void testCase3(){
 assertEquals(2/0,1);
 }

}

enabled 设置用例是否跳过执行，默认为：true ，表示不跳过。false 表示跳过执行。
timeOut 设置用例运行的超时间，3000 单位为毫秒，当用例运行时间超过 3000 毫秒则判定为失败。不管用例本身是否运行失败。
expectedExceptions 用来预设用例运行会出现的异常。例如 2/0 将会抛出 RuntimeException 类型的异常，如果出现异常则表示用例执行成功。

原始封面

requests如何解析json响应?

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

如果服务器返回json格式的数据，那么我们一般希望可以把json字符串转成python的dict数据类型。

>>> import requests

>>> r = requests.get('https://api.github.com/events')
>>> r.json()
[{u'repository': {u'open_issues': 0, u'url': 'https://github.com/...

如果JSON解析失败，r.json()会抛异常。比如假设响应的返回状态码是204(No Content)，又或者响应的返回json字符串格式有错误，那么r.json()回抛出ValueError: No JSON object could be decoded.异常。

需要引起注意的是r.json()解析成功了并不代表请求是成功的。很多服务器在响应失败的时候也会返回json字符串，如果要判断响应的状态的话，建议使用r.raise_for_status() 或者使用check r.status_code来判断返回值是否符合预期。

原始封面

（十一）JUnit5 新的用法

Mon, 13 Nov 2017 12:20:11 +0800

Junit5 新的用法

创建 JUnit5NewTests 测试类。

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertAll;

import org.junit.jupiter.api.*;

class JUnit5NewTests {

 @BeforeEach
 @DisplayName("每条用例开始时执行")
 void start(){

 }

 @AfterEach
 @DisplayName("每条用例结束时执行")
 void end(){

 }

 @Test
 void myFirstTest() {
 assertEquals(2, 1 + 1);
 }

 @Test
 @DisplayName("描述测试用例╯°□°）╯")
 void testWithDisplayName() {

 }

 @Test
 @Disabled("这条用例暂时跑不过，忽略!")
 void myFailTest(){
 assertEquals(1,2);
 }

 @Test
 @DisplayName("运行一组断言")
 public void assertAllCase() {
 assertAll("groupAssert",
 () -> assertEquals(2, 1 + 1),
 () -> assertTrue(1 > 0)
 );
 }

 @Test
 @DisplayName("依赖注入1")
 public void testInfo(final TestInfo testInfo) {
 System.out.println(testInfo.getDisplayName());
 }

 @Test
 @DisplayName("依赖注入2")
 public void testReporter(final TestReporter testReporter) {
 testReporter.publishEntry("name", "Alex");
 }

}

用法都已经通过测试用例的 @DisplayName 进行了说明，这里不再解释。

11.生成xml格式的测试报告

Wed, 25 Oct 2017 07:22:42 +0800

pytest有非常友好的命令行报告输出，在做用例开发的时候，这是极好的。然而我们在运行用例后经常会需要将测试结果广而告之，发送给相关责任人浏览，所以生成简洁美观的测试报告是很有必要的。

生成junit格式的xml报告

pytest可以生成junit格式的xml报告，在命令行中加入--junit-xml=path 参数就可以了。

pytest test_quick_start.py --junit-xml=report.xml

上面的命令在当前文件夹中生成了名为report.xml的测试报告

<?xml version="1.0" encoding="utf-8"?><testsuite errors="0" failures="0" name="pytest" skips="0" tests="1" time="0.009"><testcase classname="test_quick_start" file="test_quick_start.py" line="3" name="test_reverse" time="0.000499725341797"></testcase></testsuite>%

ci集成

jenkins在build后可以通过插件展示junit格式的测试报告，具体步骤就不描述了。

原始封面

11. 常见各类文件类型图标（新用户必看）

Mon, 16 Oct 2017 02:00:11 +0800

常见文件类型的图标介绍

Java 类相关图标介绍

官网地址：http://www.jetbrains.com/idea/webhelp/symbols.html

对于各个图标，上图的 Description 写得非常详细，但是有几个还是需要进行特别的说明下。

Source root，你可以理解为源目录，源码的作用就是用来专门放 Java 类文件，相对于编译出来的 class 文件而言，它就是源。我们一般默认名字叫 src 的目录就是源目录，但是其实并不是这样的，在 IntelliJ IDEA 中，即使叫 srcs 也是可以设置为 Source root，所以源目录跟目录命名是没有关系的，而是在于 IntelliJ IDEA 支持对任意目录进行设置为 Source root，具体设置在会后面章节进行详解。 Source root 的作用是标记该目录下的文件是可编译的。

Java class located out of the source root，由于上一条我们知道 Source root 目录是用来告诉 IntelliJ IDEA 这是编译目录，而假如你 Java 类文件没有放在该目录或是该目录的子包下，那该 Java 类则无法编译，就会被表示成这个图标。

各类文件类型图标介绍

appium新手入门（11）—— appium API 之键盘操作

Thu, 07 Sep 2017 10:20:12 +0800

模拟键盘输入也是非常重要的操作。这一小节来介绍那些关于键盘的操作。

1、sendKeys()方法

方法：

sendKeys()

用法：

driver.findElements(By.name("Name")).sendKeys("jack");

2、pressKeyCode()方法

除此之外，appium扩展提供了pressKeyCode()方法。该方法Android特有。

方法：

pressKeyCode()

发送一个键码的操作。需要一个入参。

driver.pressKeyCode(29); // 字母“a”

如果想点击Android的HOME键应该怎么实现的呢？如下

driver.pressKeyCode(AndroidKeyCode.HOME);

下面提供Android keycode参考表：

电话键

KEYCODE_CALL 拨号键 5

KEYCODE_ENDCALL 挂机键 6

KEYCODE_HOME 按键Home 3

KEYCODE_MENU 菜单键 82

KEYCODE_BACK 返回键 4

KEYCODE_SEARCH 搜索键 84

KEYCODE_CAMERA 拍照键 27

KEYCODE_FOCUS 拍照对焦键 80

KEYCODE_POWER 电源键 26

KEYCODE_NOTIFICATION 通知键 83

KEYCODE_MUTE 话筒静音键 91

KEYCODE_VOLUME_MUTE 扬声器静音键 164

KEYCODE_VOLUME_UP 音量增加键 24

KEYCODE_VOLUME_DOWN 音量减小键 25

控制键

KEYCODE_ENTER 回车键 66

KEYCODE_ESCAPE ESC键 111

KEYCODE_DPAD_CENTER 导航键确定键 23

KEYCODE_DPAD_UP 导航键向上 19

JMeter官方文档：11. 新建一个 JMS 主题的测试计划

Thu, 24 Aug 2017 08:55:11 +0800

《JMeter官方文档–翻译计划》原文地址

11.新建一个 JMS 主题的测试计划

JMS 需要下载一些可选的jar 文件。详细信息请参阅第一章：新手入门。

在本章节，将学习如何创建测试计划来测试JMS提供程序。创建5个订阅者和1个发布者。创建2个线程组并且设置每个线程组迭代10次。消息总数是（6个线程）x （1 个消息）x（重复10次）= 60 个消息。为了构建测试计划将使用以下元素：线程组 , JMS 发布者， JMS 订阅者，和图结果。

关于JMS的一般注意事项：目前有两种 JMS 采样器(samplers)。一种使用 JMS 主题(topics)，另一种使用队列(queues)。主题消息通常被称为发布/订阅消息。主题消息传递通常用于消息由生产者发布并由多个订阅者消费的情况。队列消息传递通常用于发件人期望响应的事务。消息系统与普通的HTTP请求完全不同。在HTTP中，一个用户发送一个请求并得到一个响应。消息系统可以通过同步和异步模式工作。JMS采样器需要JMS实现的jar文件（由于JMeter不提供JMS实现的jar，需要下载后放置lib库）; 例如，来自Apache ActiveMQ。请参阅这里查看 ActiveMQ 提供的 jar 列表。

11.1添加用户

第一步是添加一个线程组元素。线程组告诉JMeter想要模拟的用户数量，发送请求的频率以及发送请求的数量。

添加线程组元素，首先选择测试计划，单击鼠标右键获取添加菜单，然后选择 添加 → 线程组。此时可以在测试计划下面看到线程组元素，如果不能，可以通过在测试计划元素上单击“展开”测试计划树。

接下来，你需要修改默认属性。如果尚未选择树中的线程组元素，请先选择。此时可以看到JMeter窗口右侧的线程组控制面板（请参见下面的图11.1）

图11.1. 线程组默认设置

首先为我们的线程组提供一个更具描述性的名称。在名称字段输入: Subscribers 。

接下来，将用户（称为线程）的数量增加到 5。

在下一个字段 Ramp-Up Period 中，将该值设置为 0 秒。这个属性告诉JMeter启动每个用户之间要延迟多久。例如，如果输入一个5秒的渐变周期，JMeter将在5秒钟内完成所有用户的启动。所以，如果我们有5个用户和一个5秒钟的Ramp-Up Period值，那么用户启动之间的延迟将是1秒（5个用户/ 5秒= 1个用户每秒）。如果将该值设置为0，则JMeter将立即启动所有用户。

性能测试流程（六）——测试环境搭建

Fri, 11 Aug 2017 03:59:11 +0800

#### 性能测试环境与功能测试环境的区别那么性能测试环境与功能测试环境有所不同，对于一些企业为了节约资源，进行功能测试的测试环境，一台服务器可以运行多个系统，通过技术手段可以使系统之间是不会相互影响的（以前公司就是一台服务器上跑多个tomcat）。性能测试是要对整个系统运行的软件硬件环境进行测试的，如果某环境下运行多个系统，就很难判断其中的某个环境对资源的占用情况。
#### 保证测试环境与生产环境的一致性

1、硬件环境，包括服务器环境、与网络环境

如服务器的型号以及是否和其它应用程序共享此服务器，是否在集群环境下，是否通过BIGIP进行负载均衡，客户使用的硬件配置情况，使用的交换机型号，网络传输速率。

2、软件环境

版本一致性

包括包括操作系统、数据库、中间件的版本，被测系统的版本。

配置一致性

系统（操作系统/数据库/中间件/被测试系统）参数的配置一致，这些系统参数的配置有可能对系统造成巨大的影响。所以，除了保证测试环境与真实环境所使用的软件版本一致，也要关注其参数的配置是否一致。

3、使用场景的一致性

基础数据的一致性

包括预测的业务数据量，以及数据类型的分配。很简单的一个列子，一个系统的数据库只有10条数据和一条数据库里几千万条数据，我们在对其进行性能测试时，得到的性能指标可能会有非常大的差别。

为了保证每次测试环境的更加一致性，磁盘的使用情况以及磁盘的碎片情况也会或多或少的影响的性能。

使用模式的一致性

尽量模拟真实场景下用户的使用情况，其实，我们在做性能测试前期的需求分析，其主要目的也就是为了更真实的模拟用户的使用情况。

#### 实施策略

上面讲测试环境与生产环境保持一致所需要注意的内容。在实际的测试中，处于成本考虑，在很多情况下，我们很难申请到足够的且一致的资源，所以，很难搭建出与生产环境完全一致的一个测试环境。

我们一般通过两种策略来搭建性能测试环境（预估方式均有误差）

1、通过建模的方式实现低端硬件对高端硬件的模拟

通过配置测试来计算不同配置下的硬件性能和系统处理能力的关系，从而推导出满足系统性能的真实配置情况，这种模拟需要精确的建模，模型的采样点越多，那么得到的结果越精确，从而将在低端配置下的性能指标通过该模型转化为高端配置下的最终预计性能指标。

例如：搭建一个低端环境，首先需要对这个环境的CPU和内存进行单独的性能基准测试，同过在不同的配置的性能测试，得到一个基准信息列表，当然，在进行这个性能测试的过程中，我们要确定硬件是系统的瓶颈。如果只用一个CUP，在性能测试过程中，其使用率很低，但得到的性能数据都非常底，这起码说明CUP不是系统的瓶颈，这种情况下就无法得到想要的基准值。

如上图，在一颗CPU情况下，运行100个用户且CUP使用率接近饱和（100%）。在增加至两颗CUP的情况下，可以运行190个用户且UPU使用率接近饱和（100%），以此做记录，那么我们就可以推算出运行800个用户需要多少颗CUP。如果你在实际应用中使用的CUP型号及其频率并非完全一样，这个时候可以使用EVEREST工具计算每种CUP的得分，对其性能进行评估。内存也可以使用此方法进行测试推导，这里需要我们多进行试验，对硬件的性能以及对整个项目的结构都要做深入的了解，以便尽量减少误差。

2、通过集群的方式计算

对于较大的系统来说，单台服务器的处理能力是有限的，通常都会采用集群的方式来进行负载均衡，完成对海量请求的处理。虽然无法获得整体集群的测试环境，但是可以对集群上的一个节点进行性能测试，得出该节点的处理能力，再计算每增加一个节点的性能损失，同样也可以能过建模的方式得到大型负载均衡情况下的预计性能指标。

例如:首先在单台服务器上获得具体的性能指标，每台服务器能够承受500用户并发，平均TPS为60，响应时间为2秒，接着，添加负载均衡策略，再次测试负载策略下的数据损耗。得出数据后添加1台负载均衡服务器，测试在两台服务器下每台服务器的性能指标，以此类推，可以得到下表：

表：

负载服务器个数	并发用户数	平均TPS	响应时间
1	500	60	2
1	490	58	2
2	490	58	2
3	480	57	2

随着负载均衡服务器的添加，平均每台服务器的处理能力会逐渐稳定，从而了解在什么情况下需要多少台负载均衡服务器。

原始封面

（十一）ActionSequence

Thu, 03 Aug 2017 02:49:18 +0800

组合事件

当页面的交互比较复杂的时候，我们可能会使用到组合事件。比如先把鼠标移动到某个元素上，然后按住鼠标，将该元素拖到另一个地方。为了完成这种操作，我们就需要使用组合事件ActionSequence

组合事件中，我们可以组合鼠标和键盘的操作，这些操作将根据我们组合的顺序依次执行。

基本用法

直接使用WebDriver.actions()进行调用，不需要额外的初始化工作;
只有显示调用了perform()方法才让所有动作真正得到执行；简而言之，一定要调用perform();

driver.actions().
 keyDown(Key.SHIFT).
 click(element1).
 click(element2).
 dragAndDrop(element3, element4).
 keyUp(Key.SHIFT).
 perform();

实例方法

click( opt_elementOrButton, opt_button ): 单击，相当于把鼠标移动到元素的中心，然后点击左键
doubleClick( opt_elementOrButton, opt_button ): 双击, 相当于把鼠标移动到元素的中心，然后双击左键
this.dragAndDrop( element, location ): 拖拽，第1个参数是拖谁(WebElement)，第2个参数是拽到哪里，可以是WebElement，也可以是坐标{x: number, y: number}
this.keyDown( key ): 按下一个键，必须是{ALT, CONTROL, SHIFT, COMMAND, META}中的一个，会一直按着，除非调用keyUp()进行松开
this.keyUp( key ): 松开一个键，必须是{ALT, CONTROL, SHIFT, COMMAND, META}中的一个
this.mouseDown( opt_elementOrButton, opt_button ): 按下鼠标，除非mouseUp，否则不松开
this.mouseMove( location, opt_offset ): 把鼠标移动到元素的中心或者具体位置，当然，第2个参数可以也可以增加1个偏移量, {x: number, y: number}
this.mouseUp( opt_elementOrButton, opt_button ): 松开鼠标

11. 函数

Thu, 29 Jun 2017 08:17:22 +0800

背景

这一节里我们来了解一下什么是函数。

简单来说函数就是一段代码，只不过这段代码有名字，可能有输入和输出，我们可以使用函数的名字反复去调用这段代码。

函数主要做了下面3件事情

给一段代码命名，就像是我们之前给字符串和数字取个变量名一样
可以像之前我们在调用脚本时使用argv一样的使用传入参数
把上面2步结合起来，我们可以创建一些重复使用的脚本❤️

下面我们演示一下如何定义函数和调用函数

代码实现

新建名为print_case.py，内容如下


# *args跟之前argv差不多
def print_case(*args):
 case_number, case_name = args
 print(f"用例编号: {case_number}")
 print(f"用例名称: {case_name}")

# 2个参数
def print_case_again(case_number, case_name):
 print(f"用例编号: {case_number}")
 print(f"用例名称: {case_name}")

# 1个参数
def print_delimiter(delimiter):
 print(delimiter * 20)

# 没有参数
def print_end():
 print('打印结束')

print_case('001', '验证GET请求的返回状态码')
print_delimiter('*')
print_case_again('002', '验证GET请求的返回值')
print_delimiter('*')
print_end()

详细的看一下print_case()函数。

首先我们告诉python，我们需要定义一个函数，约定好的关键字是def，也就是define的意思
然后我们为这个函数取个名字print_case，当然了，如果你觉得这个名字不好，你也可以换一个，不过我们一般在给函数取名的时候都是言简意赅的去表明这个函数到底是要做什么
然后我们告诉python，我们需要传入*args，就像是使用argv一样。*args就是函数的参数，需要放在一对小括号里()
在这一行的结束位置，不要忘了加个:冒号，表示引出下面的函数正文
另起一行，不要忘了缩进，就像使用argv一样，取出用例编号和名称
最后打印出用例名称和编号

运行

在命令行中使用下面的命令去执行代码

$ python print_case.py

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

用例编号: 001
用例名称: 验证GET请求的返回状态码
********************
用例编号: 002
用例名称: 验证GET请求的返回值
********************
打印结束

动手时间

给代码增加注释，解释一下这段代码做了些什么
函数的调用是什么意思？你能解释一下么？
函数的参数是什么意思？你能解释一下么？
缩进是什么？python中的强制缩进又是什么意思？

常见问题

给函数命名的时候，是不是任意的名字都可以？一般来说是这样的，跟变量名类似，函数名不能以数字开头，并且一般只能包含字母数字和下划线。

（十一）设置元素等待

Thu, 29 Jun 2017 07:37:11 +0800

WebDriver提供了两种类型的等待：__显式等待__和__隐式等待__。

显式等待

WebDriver提供了显式等待方法，专门针对某个元素进行等待判断。

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedCondition;


public class TimeOut01 {

 public static void main(String[]args) throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 //显式等待， 针对某个元素等待
 WebDriverWait wait = new WebDriverWait(driver,10,1);

 wait.until(new ExpectedCondition<WebElement>(){
 @Override
 public WebElement apply(WebDriver text) {
 return text.findElement(By.id("kw"));
 }
 }).sendKeys("selenium");

 driver.findElement(By.id("su")).click();
 Thread.sleep(2000);

 driver.quit();
 }
}

WebDriverWait类是由WebDirver提供的等待方法。在设置时间内，默认每隔一段时间检测一次当前页面元素是否存在，如果超过设置时间检测不到则抛出异常。具体格式如下：

（十一）多表单切换

Tue, 20 Jun 2017 12:59:11 +0800

在Web应用中经常会遇到frame/iframe表单嵌套页面的应用，WebDriver只能在一个页面上对元素识别与定位，对于frame/iframe表单内嵌页面上的元素无法直接定位。这时就需要通过switch_to.frame()方法将当前定位的主体切换为frame/iframe表单的内嵌页面中。 ```html ... ... ``` 126邮箱登录框的结构大概是这样子的，想要操作登录框必须要先切换到iframe表单。 ```python from selenium import webdriver

driver = webdriver.Chrome() driver.get(“http://www.126.com”)

driver.switch_to.frame(‘x-URS-iframe’) driver.find_element_by_name(“email”).clear() driver.find_element_by_name(“email”).send_keys(“username”) driver.find_element_by_name(“password”).clear() driver.find_element_by_name(“password”).send_keys(“password”) driver.find_element_by_id(“dologin”).click() driver.switch_to.default_content()

driver.quit()

switch_to.frame() 默认可以直接取表单的id 或name属性。如果iframe没有可用的id和name属性，则可以通过下面的方式进行定位。
```python
……
#先通过xpth定位到iframe
xf = driver.find_element_by_xpath('//*[@id="x-URS-iframe"]')

#再将定位对象传给switch_to.frame()方法
driver.switch_to.frame(xf)
……
driver.switch_to.parent_frame()

除此之外，在进入多级表单的情况下，还可以通过switch_to.default_content()跳回最外层的页面。

原始封面

（十二）Docker Machine介绍

Mon, 22 Jan 2018 14:20:11 +0800

官方文档：https://docs.docker.com/machine/overview/

可以使用Docker Machine做什么？

在Mac或Windows上安装并运行Docker
配置和管理多个远程Docker主机
提供Swarm集群

什么是Docker Machine?

Docker Machine是一个工具，可以让你在虚拟主机上安装Docker Engine，并用docker-machine命令管理主机。你可以使用计算机在本地Mac或Windows计算机上，公司网络，数据中心或云提供商（如Azure，AWS或Digital Ocean）上创建Docker主机。

使用docker-machine命令，你可以启动，检查，停止和重新启动托管主机，升级Docker客户端和守护进程，并配置Docker客户端与主机通信。

将机器CLI指向正在运行的托管主机，并且可以直接在该主机上运行docker命令。例如，运行docker-machine env default指向一个名为default的主机，按照屏幕上的说明完成env设置，然后运行docker ps，docker run hello-world等等。

Machine是在Docker v1.12之前在Mac或Windows上运行Docker的唯一方法。从测试版和Docker v1.12开始，Docker for Mac和Docker for Windows作为本地应用程序提供，并且是更新桌面和笔记本电脑上更好的选择。我们鼓励你尝试这些新的应用程序。 Docker for Mac和Docker for Windows的安装程序包括Docker Machine和Docker Compose。

如果你不确定从哪里开始，请参阅Docker入门，它将指导您完成Docker的简要端到端教程。

为什么要使用Docker Machine?

Docker Machine使你能够在各种类型的Linux上配置多个远程Docker主机。

此外，Machine允许你在旧版Mac或Windows系统上运行Docker，如上一主题中所述。

Docker Machine有这两个广泛的用例。

你有一个较旧的桌面系统，并希望在Mac或Windows上运行Docker

如果你主要工作不符合新版Docker for Mac和Docker for Windows应用程序要求的较旧的Mac或Windows笔记本电脑或台式机上，那么需要在本地运行Docker机器运行Docker Engine。使用Docker Toolbox安装程序在Mac或Windows上安装Docker Machine可以为本地虚拟机配置Docker Engine，使您能够连接它并运行docker命令。

我想在远程系统上配置Docker主机

（十二）TestNG 生成测试报告

Sat, 25 Nov 2017 12:10:11 +0800

TestNG 默认自带的有HTML格式的测试报告。这也充分说明拿它来做 UI 自动化测试的优势。

通过 Maven 生成报告

切换到 TestngTest 项目的跟目录下，通过 mvn test 命令运行测试。

TestngTest> mvn test

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building TestngTest 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ TestngTest
 --- [WARNING] Using platform encoding (GBK actually) to copy filtered resources,
 i.e. build is platform dependent!
[INFO] Copying 0 resource

...

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running TestSuite
Configuring TestNG with: org.apache.maven.surefire.testng.conf.TestNG652Configurator@104e3b2
Tests run: 19, Failures: 5, Errors: 0, Skipped: 2, Time elapsed: 3.862 sec <<< FAILURE!

在该系列教程开始前，我已经说明了整个项目基于 Maven 创建。

requests如何查看cookies和发送cookies?

Wed, 22 Nov 2017 03:23:57 +0800

如果某个响应中包含一些 cookie，你可以快速访问它们：

>>> url = 'http://example.com/some/cookie/setting/url'
>>> r = requests.get(url)

>>> r.cookies['example_cookie_name']
'example_cookie_value'

要想发送你的cookies到服务器，可以使用 cookies 参数：

>>> url = 'http://httpbin.org/cookies'
>>> cookies = dict(cookies_are='working')

>>> r = requests.get(url, cookies=cookies)
>>> r.text
'{"cookies": {"cookies_are": "working"}}'

Cookie 的返回对象为 RequestsCookieJar，它的行为和字典类似，但界面更为完整，适合跨域名跨路径使用。你还可以把 Cookie Jar 传到 Requests 中：

>>> jar = requests.cookies.RequestsCookieJar()
>>> jar.set('tasty_cookie', 'yum', domain='httpbin.org', path='/cookies')
>>> jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/elsewhere')
>>> url = 'http://httpbin.org/cookies'
>>> r = requests.get(url, cookies=jar)
>>> r.text
'{"cookies": {"tasty_cookie": "yum"}}'

原始封面

（十二）补充：JUnit 注解之Rule

Mon, 13 Nov 2017 12:15:11 +0800

一个JUnit Rule就是一个实现了TestRule的类，这些类的作用类似于 @Before、@After，是用来在每个测试方法的执行前后执行一些代码的一个方法。那为什么不直接用这些 @Before、@After呢？这是因为它们都只能作用于一个类，如果同一个setup需要在两个类里面同时使用，那么你就要在两个测试类里面定义相同的@Before方法，然后里面写相同的代码，这就造成了代码重复。

此外，JUnit Rule还能做一些 @Before、@After这些注解做不到的事情，那就是他们可以动态的获取将要运行的测试类、测试方法的信息。

使用框架自带的Rule

除了增加Rule特性，新版JUnit还添加了很多核心Rule

TemporaryFolder：测试可以创建文件与目录并且会在测试运行结束后将其删除。这对于那些与文件系统打交道且独立运行的测试来说很有用。
ExternalResource：这是一种资源使用模式，它会提前建立好资源并且会在测试结束后将其销毁。这对于那些使用socket、嵌入式服务器等资源的测试来说很有用。
ErrorCollector：可以让测试在失败后继续运行并在测试结束时报告所有错误。这对于那些需要验证大量独立条件的测试来说很有用（尽管这本身可能是个“test smell”）。
ExpectedException：可以在测试中指定期望的异常类型与消息。
Timeout：为类中的所有测试应用相同的超时时间。

例如，TimeOut这个Rule的使用。

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Timeout;


public class RuleTestDemo {

 //使用Timeout这个Rule
 @Rule
 public Timeout timeout = new Timeout(1000); 

 @Test
 public void testMethod1() throws Exception {
 Thread.sleep(1001);
 }

 @Test
 public void testMethod2() throws Exception {
 Thread.sleep(999);
 }
}

使用JUnit所提供的Timeout类，该类用于控制测试用例的执行超时时间。这里设置为1秒，当用例执行超过1秒则失败。接下来分别在 testMethod1和testMethod2两个用例中使用sleep()方法来控制用例的执行时间，显然testMethod1超过1秒，则运行失败。

12. IntelliJ IDEA 搜索快的原因：索引（新用户必看）

Mon, 16 Oct 2017 01:00:11 +0800

IntelliJ IDEA 缓存和索引介绍和清理方法

缓存和索引介绍

在《IntelliJ IDEA 界面介绍》章节里已经点到了 IntelliJ IDEA 首次加载项目的时候，都会创建索引，而创建索引的时间跟项目的文件多少成正比，我也简单强调了 IntelliJ IDEA 索引的重要性。这里我们再对此进行详细说明索引、缓存对 IntelliJ IDEA 的重要性。

通过《常见文件类型的图标介绍》章节，你已经认识到 IntelliJ IDEA 下各个文件类型的图标是什么样子的。其中有一个图标我是专门进行了讲解： Java class located out of the source root。我们也都知道该图标是表示 Java 类文件没有在 Source root 目录下的文件夹下会显示此图标，但是其实还有一种情况也是会显示此图标的。那就是：在 IntelliJ IDEA 创建索引过程中，所有的 Java类都是这个图标，如果你项目大的话很容易观察到的，几个文件的小项目倒是不一定会看到。所以在 IntelliJ IDEA 创建索引过程即使你编辑了代码也是编译不了、运行不起来的，所以还是安安静静等 IntelliJ IDEA 创建索引完成。

IntelliJ IDEA 的缓存和索引主要是用来加快文件查询，从而加快各种查找、代码提示等操作的速度，所以 IntelliJ IDEA 的索引的重要性我再唠叨一万遍都不为过。但是，IntelliJ IDEA 的索引和缓存并不是一直会良好地支持 IntelliJ IDEA 的，这某些特殊条件下，IntelliJ IDEA 的缓存和索引文件也是会损坏的，比如断电、蓝屏引起的强制关机，当你重新打开 IntelliJ IDEA，基本上百分八十的可能 IntelliJ IDEA 都会报各种莫名其妙错误，甚至项目打不开，IntelliJ IDEA 主题还原成默认状态。也有一些即使没有断电、蓝屏，也会有莫名奇怪的问题的时候，也很有可能是 IntelliJ IDEA 缓存和索引出问题，这种情况还不少。遇到此类问题也不用过多担心，下面就来讲解如何解决。

appium新手入门（12）—— appium API 之 TouchAction 操作

Thu, 07 Sep 2017 10:10:12 +0800

Appium的辅助类，主要针对手势操作，比如滑动、长按、拖动等。

1、按压控件

方法：

press()

开始按压一个元素或坐标点（x,y）。通过手指按压手机屏幕的某个位置。

press(WebElement el, int x, int y)

press也可以接收屏幕的坐标（x,y）。

例：

TouchAction(driver).press(x=0,y=308).release().perform()

除了press()方法之外，本例中还用到了别外两个新方法。

release() 结束的行动取消屏幕上的指针。
Perform() 执行的操作发送到服务器的命令操作。

2、长按控件

方法：

longPress()

开始按压一个元素或坐标点（x,y）。相比press()方法，longPress()多了一个入参，既然长按，得有按的时间吧。duration以毫秒为单位。1000表示按一秒钟。其用法与press()方法相同。

longPress(WebElement el, int x, int y, Duration duration)

例：

TouchAction action = new TouchAction(driver);
action.longPress(names.get(1),1000).perform().release();
action.longPress(1 ,302,1000).perform().release();

3、点击控件

方法：

tap()

对一个元素或控件执行点击操作。用法参考press()。

tap(WebElement el, int x, int y)

例：

TouchAction action = new TouchAction(driver);
action.tap(names.get(1)).perform().release();
action.tap(1 ,302).perform().release();

4、移动

方法：

moveTo()

将指针（光标）从过去指向指定的元素或点。

movTo(WebElement el, int x, int y)

性能测试流程（七）——测试执行

Fri, 11 Aug 2017 02:59:11 +0800

参考测试计划，大概执行过程如下：

1、准备测试数据

2、使用测试工具模拟测试点，回放OK

3、根据测试策略，使用不同的虚拟用户和测试组合运行测试。

4、监控系统CPU、内存、中间件，数据库的性能，收集数据。

5、重复3、4。

原始封面

（十二）定位一组元素

Wed, 02 Aug 2017 07:27:57 +0800

定位一组元素

定位一组元素一般有如下的作用

找到一组属性部分相同的元素，遍历元素，做一些批量操作
找到一组属性部分相同的元素，遍历元素，返回1个或几个特定的元素，做更精确的定位

findElements方法可以定位一组元素。该方法的参数跟findElement方法一致。

目的

学会使用findElements方法
学会使用getAttribute方法

场景

打印测试教程网中所有的selenium javascript教程的链接

代码

var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get('http://www.testclass.net/selenium_javascript/');

dr.findElements(By.css('.post-stub a')).then(function(links){
 for (var i = 0; i < links.length; i++) {
 links[i].getAttribute('href').then(function(href) {
 console.log(href);
 });
 }
});
dr.quit();

运行结果

如下所示

http://www.testclass.net/selenium_javascript/init/
http://www.testclass.net/selenium_javascript/simple_automation_scripts/
http://www.testclass.net/selenium_javascript/view_document/
http://www.testclass.net/selenium_javascript/by_id/
http://www.testclass.net/selenium_javascript/by_name/
http://www.testclass.net/selenium_javascript/by_classname/
http://www.testclass.net/selenium_javascript/by_link_text/
http://www.testclass.net/selenium_javascript/by_css/
http://www.testclass.net/selenium_javascript/by_xpath/
http://www.testclass.net/selenium_javascript/keyboard/
http://www.testclass.net/selenium_javascript/action_sequence/
......
......
......
......

原始封面

12. 函数与变量

Wed, 28 Jun 2017 08:17:22 +0800

背景

对于初学者来说函数的概念比较的烧脑，刚开始理解起来会各种困难，不过没关系，继续多多练习，习惯之后就不会有太多问题了。

这一节里我们解决一个小问题，就是函数里的变量名和函数外的变量名是不是会冲突的问题。

结论是不冲突，下面我们演示一下具体情况。

代码实现

新建名为print_case01.py，内容如下


def print_case_count(success, failed):
 total_count = success + failed
 print(f"一共{total_count}个用例, 成功{success}个, 失败{failed}个")

def print_end():
 print('打印结束')

print('第一次运行')
print_case_count(95, 5)

print('第二次运行')
success = 101
failed = 0
print_case_count(success, failed)

print('第三次运行')
total = 100
failed = 7
print_case_count(total - failed, failed)

print_end()

上面的代码说明了一些问题

函数调用有很多的方式，传参的时候我们可以直接传值，传变量，甚至是合法的表达式(total - failed)
函数外的变量名不会影响函数内的，另一种说法是我们可以在函数内用函数外相同的变量名

运行

在命令行中使用下面的命令去执行代码

$ python print_case01.py

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

第一次运行 
一共100个用例, 成功95个, 失败5个 
第二次运行 
一共101个用例, 成功101个, 失败0个 
第三次运行 
一共100个用例, 成功93个, 失败7个 
打印结束

动手时间

修改print_case_count()函数，使其可以输出用例的通过率
自行去了解一下python中变量的作用域，推荐搜索关键字python variable scope
自行去了解什么是全局变量，什么是局部变量

常见问题

为什么搜索的时候推荐英文关键字？英文关键字可以使我们找到第一手官方的解释，准确性更高。另外阅读一些英文文档也不是啥坏事。
怎么去计算用例的通过率？公式大概是success_count / total_count，注意算出来的结果应该是浮点型
什么是浮点型？简单理解为带有小数位的数，如果你对这个答案不满意，你可以看一下这里

（十二）定位一组元素

Wed, 28 Jun 2017 07:37:11 +0800

在第（五）节我们已经学习了8种定位方法，那8种定位方法是针对单个元素定位的， WebDriver还提供了另外8种用于定位一组元素的方法。

import org.openqa.selenium.By;
......
findElements(By.id())
findElements(By.name())
findElements(By.className())
findElements(By.tagName())
findElements(By.linkText())
findElements(By.partialLinkText())
findElements(By.xpath())
findElements(By.cssSelector())

定位一组元素的方法与定位单个元素的方法类似，唯一的区别是在单词 findElement 后面多了一个 s 表示复数。

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.List;


public class ElementsDemo {

 public static void main(String[] args) throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com/");

 WebElement search_text = driver.findElement(By.id("kw"));
 search_text.sendKeys("selenium");
 search_text.submit();
 Thread.sleep(2000);

 //匹配第一页搜索结果的标题， 循环打印
 List<WebElement> search_result = driver.findElements(By.xpath("//div/div/h3"));

 //打印元素的个数
 System.out.println(search_result.size());

 // 循环打印搜索结果的标题
 for(WebElement result : search_result){
 System.out.println(result.getText());
 }

 System.out.println("-------我是分割线---------");

 //打印第n结果的标题
 WebElement text = search_result.get(search_result.size() - 10);
 System.out.println(text.getText());

 driver.quit();
 }
}

打印结果：

（十二）多窗口切换

Mon, 19 Jun 2017 12:59:11 +0800

在页面操作过程中有时候点击某个链接会弹出新的窗口，这时就需要主机切换到新打开的窗口上进行操作。WebDriver提供了switch_to.window()方法，可以实现在不同的窗口之间切换。以百度首页和百度注册页为例，在两个窗口之间的切换如下图。 ![](http://orru5lls3.bkt.clouddn.com/more_windows_n.png) ```python from selenium import webdriver import time

driver = webdriver.Firefox() driver.implicitly_wait(10) driver.get(“http://www.baidu.com”)

获得百度搜索窗口句柄

sreach_windows = driver.current_window_handle

driver.find_element_by_link_text(‘登录’).click() driver.find_element_by_link_text(“立即注册”).click()

获得当前所有打开的窗口的句柄

all_handles = driver.window_handles

进入注册窗口

for handle in all_handles: if handle != sreach_windows: driver.switch_to.window(handle) print(’now register window!’) driver.find_element_by_name(“account”).send_keys(‘username’) driver.find_element_by_name(‘password’).send_keys(‘password’) time.sleep(2) # ……

driver.quit()

在本例中所涉及的新方法如下：

* current_window_handle：获得当前窗口句柄。
* window_handles：返回所有窗口的句柄到当前会话。
* switch_to.window()：用于切换到相应的窗口，与上一节的switch_to.frame()类似，前者用于不同窗口的切换，后者用于不同表单之间的切换。




原始封面

![课程图片](https://images.unsplash.com/photo-1434873740857-1bc5653afda8?w=300)

（十三）Docker Machine安装

Mon, 22 Jan 2018 14:18:11 +0800

在macOS和Windows上，当你安装Docker for Mac，Docker for Windows或Docker Toolbox时，Machine将与其他Docker产品一起安装。

如果你只需要Docker Machine，则可以按照下一节中的说明直接安装Machine二进制文件。你可以在GitHub上的docker/machine release 页面上找到最新版本的二进制文件。

直接安装

1、安装 Docker。

2、下载Docker Machine二进制文件并将其解压到PATH。

如果你是 macOS 系统，运行:

$ curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` >/usr/local/bin/docker-machine && \
 chmod +x /usr/local/bin/docker-machine

如果你是 Linux 系统，运行:

$ curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine && \
sudo install /tmp/docker-machine /usr/local/bin/docker-machine

如果你是 Windows 系统，通过Git BASH 运行:

$ if [[ ! -d "$HOME/bin" ]]; then mkdir -p "$HOME/bin"; fi && \
curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-Windows-x86_64.exe > "$HOME/bin/docker-machine.exe" && \
chmod +x "$HOME/bin/docker-machine.exe"

注意：只有当你使用像Git BASH这样的支持Linux命令（如chmod）的终端模拟器时，上面的命令才能在Windows上运行。

requests如何处理url的重定向?

Wed, 22 Nov 2017 03:23:57 +0800

默认情况下，除了HEAD请求, Requests 会自动处理所有重定向。

如果你使用的是GET、OPTIONS、POST、PUT、PATCH 或者 DELETE，那么你可以通过 allow_redirects 参数禁用重定向处理：

>>> r = requests.get('http://github.com', allow_redirects=False)
>>> r.status_code
301
>>> r.history
[]

可以使用history方法来追踪重定向

>>> r = requests.get('http://github.com')

>>> r.url
'https://github.com/'

>>> r.status_code
200

>>> r.history
[<Response [301]>]

如果你使用了 HEAD 方法，你也可以启用重定向：

>>> r = requests.head('http://github.com', allow_redirects=True)
>>> r.url
'https://github.com/'
>>> r.history
[<Response [301]>]

原始封面

13. Java 文件编译方式（新用户必看）

Mon, 16 Oct 2017 00:00:11 +0800

IntelliJ IDEA 编译方式介绍

编译方式介绍

相比较于 Eclipse 的实时自动编译，IntelliJ IDEA 的编译更加手动化，虽然 IntelliJ IDEA 也支持通过设置开启实时编译，但是不建议，因为太占资源了。IntelliJ IDEA 编译方式除了手工点击编译按钮进行编译之外，还有就是在容器运行之前配置上一个编译事件，先编译后运行。默认下 IntelliJ IDEA 也都是这样的设置，所以实际开发中你也不用太注意编译这件事。虽然 IntelliJ IDEA 没有实时编译，但是对于代码检查完全是没有影响。但是多个类之间的关联关系还是要等 Make 或 Rebuild 触发的时候才会做相关检查的。

在 IntelliJ IDEA 里，编译方式一共有三种：

Compile：对选定的目标（Java 类文件），进行强制性编译，不管目标是否是被修改过。

Rebuild：对选定的目标（Project），进行强制性编译，不管目标是否是被修改过，由于 Rebuild 的目标只有 Project，所以 Rebuild 每次花的时间会比较长。

Make：使用最多的编译操作。对选定的目标（Project 或 Module）进行编译，但只编译有修改过的文件，没有修改过的文件不会编译，这样平时开发大型项目才不会浪费时间在编译过程中。

编译触发按钮

如上图标注 1 所示，Compile 的操作有：Compile 指定类

如上图标注 1 所示，Rebuild 的操作有：Rebuild Project

如上图标注 1 所示，Make 的操作有：Make Project、Make Module

运行之前的编译

appium新手入门（13）—— appium API 之其他操作

Thu, 07 Sep 2017 10:01:12 +0800

其它操作针对移动设备上特有的一些操作。

1、熄屏

方法：

lockDevice()

点击电源键熄灭屏幕。

在iOS设备可以设置熄屏一段时间。Android上面不带参数，所以熄屏之后就不会再点亮屏幕了。

driver.lockDevice(1000); // iOS
driver.lockDriice(); //Android

2、当前Activity（Android only）

方法：

currentActivity()

得到当前应用的activity。只适用于Android。例（通讯录）：

String ca = driver.currentActivity();
System.out.print(ca);
-------------输出结果为-------------
.activities.PeopleActivity

3、收起键盘

方法：

hideKeyboard()

收起键盘，这个方法很有用，当我们对一个输入框输入完成后，需要将键盘收起，再切换到一下输入框进行输入。

driver.hideKeyboard(); //收起键盘

4、滑动

方法：

swipe()

模拟用户滑动。将控件或元素从一个位置（x,y）拖动到另一个位置（x,y）。

swipe(int startx, int starty, int endx, int endy, int duration)

start_x：开始滑动的x坐标。
start_y：开始滑动的y坐标。
end_x：结束滑动的x坐标。
end_y：结束滑动的y坐标。
duration：持续时间。

例：

driver.swipe(75, 500, 75, 0, 800);

5、拉出文件

方法：

pullFile()

从设备中拉出文件。

例：

driver.pullFile('Library/AddressBook/AddressBook.sqlitedb')

6、推送文件

方法：

pushFile()

推送文件到设备中去。

pushFile(String remotePath, byte[] base64Data)

性能测试流程（八）——性能调优

Fri, 11 Aug 2017 01:59:11 +0800

![](http://img.testclass.net/tuning.jpg)

一般系统的瓶颈

性能测试调优需要先发现瓶颈，那么系统一般会存在哪些瓶颈：

硬件上的性能瓶颈：

一般指的是CPU、内存、磁盘I/O 方面的问题，分为服务器硬件瓶颈、网络瓶颈（对局域网可以不考虑）、服务器操作系统瓶颈（参数配置）、中间件瓶颈（参数配置、数据库、web服务器等）、应用瓶颈（SQL 语句、数据库设计、业务逻辑、算法等）。

应用软件上的性能瓶颈：

一般指的是应用服务器、web 服务器等应用软件，还包括数据库系统。

例如：中间件weblogic 平台上配置的JDBC连接池的参数设置不合理，造成的瓶颈。

应用程序上的性能瓶颈：

一般指的是开发人员新开发出来的应用程序。

例如，程序架构规划不合理，程序本身设计有问题（串行处理、请求的处理线程不够），造成系统在大量用户访问时性能低下而造成的瓶颈。

操作系统上的性能瓶颈：

一般指的是windows、UNIX、Linux等操作系统。

例如，在进行性能测试，出现物理内存不足时，虚拟内存设置也不合理，虚拟内存的交换效率就会大大降低，从而导致行为的响应时间大大增加，这时认为操作系统上出现性能瓶颈。

网络设备上的性能瓶颈：

一般指的是防火墙、动态负载均衡器、交换机等设备。

例如，在动态负载均衡器上设置了动态分发负载的机制，当发现某个应用服务器上的硬件资源已经到达极限时，动态负载均衡器将后续的交易请求发送到其他负载较轻的应用服务器上。在测试时发现，动态负载均衡器没有起到相应的作用，这时可以认为网络瓶颈。性能测试出现的原因及其定位十分复杂，这里只是简单介绍常见的几种瓶颈类型和特征，而性能测试所需要做的就是根据各种情况因素综合考虑，然后协助开发人员\DBA\运维人员一起定位性能瓶颈。

#### 一般性能调优步骤 ---

步骤一：确定问题

应用程序代码：在通常情况下，很多程序的性能问题都是写出来的，因此对于发现瓶颈的模块，应该首先检查一下代码。

数据库配置：经常引起整个系统运行缓慢，一些诸如oracle 的大型数据库都是需要DBA进行正确的参数调整才能投产的。

操作系统配置：不合理就可能引起系统瓶颈。

硬件设置：硬盘速度、内存大小等都是容易引起瓶颈的原因，因此这些都是分析的重点。

网络：网络负载过重导致网络冲突和网络延迟。

步骤二：分析问题

当确定了问题之后，我们要明确这个问题影响的是响应时间吞吐量，还是其他问题？是多数用户还是少数用户遇到了问题？如果是少数用户，这几个用户与其它用户的操作有什么不用？系统资源监控的结果是否正常？CPU的使用是否到达极限？I/O 情况如何？问题是否集中在某一类模块中？是客户端还是服务器出现问题？系统硬件配置是否够用？实际负载是否超过了系统的负载能力？是否未对系统进行优化？

通过这些分析及一些与系统相关的问题，可以对系统瓶颈有更深入的了解，进而分析出真正的原因。

步骤三：确定调整目标和解决方案

得高系统吞吐量，缩短响应时间，更好地支持并发。

步骤四：测试解决方案

对通过解决方案调优后的系统进行基准测试。（基准测试是指通过设计科学的测试方法、测试工具和测试系统，实现对一类测试对象的某项性能指标进行定量的和可对比的测试）

步骤五：分析调优结果

系统调优是否达到或者超出了预定目标？系统是整体性能得到了改善，还是以系统某部分性能来解决其他问题。调优是否可以结束了。

最后，如果达到了预期目标，调优工作就基本可以结束了。

原始封面

（十三）切换frame

Tue, 01 Aug 2017 07:27:57 +0800

为什么要切换

当我们要定位的元素位于页面中的iframe或frame标签中时，我们必须将定位的上下文切换到对应的frame中去，否则我们将没有办法定位到frame中的元素，这是套路，可以先无脑记住。

目的

学会使用switchTo().frame(id)方法

switchTo().frame(id)方法详解

id可以是1个数字，从0开始。switchTo().frame(0)表示切换到页面上的第1个frame，依此类推;
id也可以是1个WebElement对象，也就是需要切换到的frame;
id可以是null，等于是调用了switchTo().defaultContent()方法;

switchTo().defaultContent()方法

切换回到主页面，调用这个方法会将定位的上下文切回主页面，此后就可以继续定位主页面上的元素了。

示例代码

var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get('some url');

// 切换到第2个frame进行元素定位
dr.switchTo().frame(1).then(function() {
 dr.findElement(By.id('this-element-is-in-frame'));
});

// 切换到第id==example-frame的frame中进行元素定位
dr.findElement(By.id('example-frame')).then(function(iframe) {
 dr.switchTo().frame(iframe).then(function() {
 dr.findElement(By.id('this-element-is-in-frame'));
 });
});

// 切换回主页面
dr.switchTo().defaultContent();

原始封面

13. 函数与文件

Tue, 27 Jun 2017 08:17:22 +0800

背景

继续通过练习来熟悉函数。

这一节里我们将使用函数和文件的知识来重构第9节中的内容。

什么是重构

重构简单来说就是在不改变原有代码功能的情况下修改先前的代码实现。

测试同学一般都需要对重构提高警惕，这是因为

重构中如果没有单元测试进行辅助的话，代码可能会隐藏问题
重构的需求往往安排较少的测试进行回归，测试力度可能不够

利用已有的用例文件

不出意外你应该拥有名为case001.txt的文本文件，内容如下:

用例编号: itest001
用例名称: 登录成功
测试数据: 用户名:example;密码:example
测试步骤: 略
测试断言: 应该可以正确跳转到www.itest.info

代码实现

新建名为read_case01.py的文件，内容如下


from sys import argv

script, file_path = argv

def read_file(file_name):
 file_obj = open(file_name)
 print(file_obj.read())
 file_obj.close()

print(f"读取文件: {file_path}")
read_file(file_path)

运行

在命令行中使用下面的命令去执行代码

$ python read_case01.py case001.txt

你应该可以看到

按照下面展示的情况进行输入，如果没有出错的话，你应该可以看到命令行窗口显示如下的内容

读取文件: case001.txt

用例编号: itest001
用例名称: 登录成功
测试数据: 用户名:example;密码:example
测试步骤: 略
测试断言: 应该可以正确跳转到www.itest.info

动手时间

如果要求你不能在read_file中进行打印，要完成上面的内容，你应该怎么做？
搜索一下什么是函数的返回值，了解一下基本概念

原始封面

（十三）多表单切换

Tue, 27 Jun 2017 07:37:11 +0800

在 Web 应用中经常会遇到 frame/iframe 表单嵌套页面的应用， WebDriver 只能在一个页面上对元素识别与定位，对于 frame/iframe 表单内嵌页面上的元素无法直接定位。这时就需要通过 switchTo().frame()方法将当前定位的主体切换为 frame/iframe 表单的内嵌页面中。

<html>
 <body>
 ...
 <iframe id="x-URS-iframe" ...>
 <html>
 <body>
 ...
 <input name="email" >

126邮箱登录框的结构大概是这样子的，想要操作登录框必须要先切换到iframe表单。

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;


public class MailLogin {

 public static void main(String[] args){

 WebDriver driver = new ChromeDriver();
 driver.get("http://www.126.com");

 WebElement xf = driver.findElement(By.xpath("//*[@id='loginDiv']/iframe"));
 driver.switchTo().frame(xf);
 driver.findElement(By.name("email")).clear();
 driver.findElement(By.name("email")).sendKeys("username");
 driver.findElement(By.name("password")).clear();
 driver.findElement(By.name("password")).sendKeys("password");
 driver.findElement(By.id("dologin")).click();
 driver.switchTo().defaultContent();
 //……
 }
}

如果完成了在当前表单上的操作，则可以通过switchTo().defaultContent()方法跳出表单。

（十三）警告框处理

Sun, 18 Jun 2017 12:59:11 +0800

在WebDriver中处理JavaScript所生成的alert、confirm以及prompt十分简单，具体做法是使用 switch_to.alert 方法定位到 alert/confirm/prompt，然后使用text/accept/dismiss/ send_keys等方法进行操作。

text：返回 alert/confirm/prompt 中的文字信息。
accept()：接受现有警告框。
dismiss()：解散现有警告框。
send_keys(keysToSend)：发送文本至警告框。keysToSend：将文本发送至警告框。

如下图，百度搜索设置弹出的窗口是不能通过前端工具对其进行定位的，这个时候就可以通过switch_to_alert()方法接受这个弹窗。

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
import time

driver = webdriver.Firefox()
driver.implicitly_wait(10)
driver.get('http://www.baidu.com')

# 鼠标悬停至“设置”链接
link = driver.find_element_by_link_text('设置')
ActionChains(driver).move_to_element(link).perform()

# 打开搜索设置
driver.find_element_by_link_text("搜索设置").click()

# 保存设置
driver.find_element_by_class_name("prefpanelgo").click()
time.sleep(2)

# 接受警告框
driver.switch_to.alert.accept()

driver.quit()

通过switch_to_alert()方法获取当前页面上的警告框，并使用accept()方法接受警告框。

原始封面

（十四）Docker Machine基本使用

Mon, 22 Jan 2018 14:18:11 +0800

这一小节演示Machine的基本使用。

以 macOS 系统为例：

创建一个machine

指令：

$ docker-machine create --driver virtualbox my-machine

Creating CA: /Users/fnngj/.docker/machine/certs/ca.pem
Creating client certificate: /Users/fnngj/.docker/machine/certs/cert.pem
Running pre-create checks...
Creating machine...
(my-machine) Copying /Users/fnngj/.docker/machine/cache/boot2docker.iso to /Users/fnngj/.docker/machine/machines/my-machine/boot2docker.iso...
(my-machine) Creating VirtualBox VM...
(my-machine) Creating SSH key...
(my-machine) Starting the VM...
(my-machine) Check network to re-create if needed...
(my-machine) Found a new host-only adapter: "vboxnet0"
(my-machine) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env my-machine

查看machine列表

指令：

$ docker-machine ls

NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
my-machine - virtualbox Running tcp://192.168.99.100:2376 v18.01.0-ce

可以看到我们刚创建的“my-machine”已出现在 machine 的列表当中。

查看 machine 的环境变量的配置信息。

指令：

$ docker-machine env my-machine

export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.99.100:2376"
export DOCKER_CERT_PATH="/Users/fnngj/.docker/machine/machines/my-machine"
export DOCKER_MACHINE_NAME="my-machine"
# Run this command to configure your shell:
# eval $(docker-machine env my-machine)

连接到machine的shell。

指令：

requests如何处理二进制的响应内容？

Wed, 22 Nov 2017 03:23:57 +0800

官方文档

有时候服务器返回的数据不是文本的，而是二进制的，这时候我们就需要处理二进制的内容。

Requests中可以使用content方法来返回二进制的响应内容，比如

>>> r.content
b'[{"repository":{"open_issues":0,"url":"https://github.com/...

如果响应是gzip压缩过的，Requests会自动解压。

下面这个例子演示了如何从服务器返回的二进制内容创建图片。

>>> from PIL import Image
>>> from io import BytesIO

>>> i = Image.open(BytesIO(r.content))

原始封面

14. 项目相关概念（新用户必看）

Sun, 15 Oct 2017 23:00:11 +0800

IntelliJ IDEA 项目相关的几个重要概念介绍

必备材料介绍

IntelliJ IDEA 对其他 IDE 转过来的用户有特别优待，对其专门整理了非常棒的资料，还请其他 IDE 过来的用户抽时间查看，会有很大帮助：

Eclipse 用户可以看：https://www.jetbrains.com/idea/help/eclipse.html

NetBeans 用户可以看：https://www.jetbrains.com/idea/help/netbeans.html

Project 和 Module 介绍

这两个概念是 IntelliJ IDEA 的必懂知识点之一，请务必要学会。

如果你是 Eclipse 用户，并且已经看了上面给的链接，那 IntelliJ IDEA 首先告诉你一个非常重要的事情：IntelliJ IDEA 没有类似 Eclipse 工作空间（workspace）的概念的。很多从 Eclipse 转过来的人总是下意识地要再同一个窗口管理 n 个项目，这在 IntelliJ IDEA 是无法得到。IntelliJ IDEA 提供的体验是：一个 Project 打开一个 Window 窗口。

对于 Project，IntelliJ IDEA 是这样解释的：

Whatever you do in IntelliJ IDEA, you do that in the context of a project. A project is an organizational unit that represents a complete software solution. It serves as a basis for coding assistance, bulk refactoring, coding style consistency, etc.

Your finished product may be decomposed into a series of discrete, isolated modules, but it’s a project definition that brings them together and ties them into a greater whole.

Projects don’t themselves contain development artifacts such as source code, build scripts, or documentation. They are the highest level of organization in the IDE, and they define project-wide settings as well as collections of what IntelliJ IDEA refers to as modules and libraries.

20170630 更新新地址：https://www.jetbrains.com/help/idea/about-projects.html

对于 Module，IntelliJ IDEA 是这样解释的：

（十四）处理下拉列表 select

Tue, 01 Aug 2017 01:49:18 +0800

什么是下拉列表

<select id="select">
 <optgroup label="Option Group">
 <option>Option One</option>
 <option>Option Two</option>
 <option>Option Three</option>
 </optgroup>
</select>

下拉列表的标签是select，如上所示，其中

select表示下拉列表
option表示列表里的子项

上面的html里，这个下拉列表中一共有3项，分别是Option One, Option Two和Option Three。

目的

学会选择下拉列表里的特定项目
学会使用层级定位

场景

选择上面html代码所示的下拉列表的最后一项，也就是Option Three。

代码


var path = require('path');
var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var testFile = "file://" + path.join(__dirname, "index.html")

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get(testFile)

dr.findElement(By.id('select')).then(function(select) {
 dr.findElements(By.css('option')).then(function(options) {
 options[options.length - 1].click();
 });
});

运行结果

原始封面

（十四）多窗口切换

Tue, 27 Jun 2017 07:37:11 +0800

在页面操作过程中有时候点击某个链接会弹出新的窗口，这时就需要主机切换到新打开的窗口上进行操作。WebDriver提供了switchTo().window()方法可以实现在不同的窗口之间切换。

以百度首页和百度注册页为例，在两个窗口之间的切换如下图。

实现窗口切换的代码如下：


import java.util.Set;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class MoreWindows {

 public static void main(String[] arge) throws InterruptedException{

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 //获得当前窗口句柄
 String search_handle = driver.getWindowHandle();

 //打开百度注册窗口
 driver.findElement(By.linkText("登录")).click();
 Thread.sleep(3000);
 driver.findElement(By.linkText("立即注册")).click();

 //获得所有窗口句柄
 Set<String> handles = driver.getWindowHandles();

 //判断是否为注册窗口， 并操作注册窗口上的元素
 for(String handle : handles){
 if (handle.equals(search_handle)==false){
 //切换到注册页面
 driver.switchTo().window(handle);
 System.out.println("now register window!");
 Thread.sleep(2000);
 driver.findElement(By.name("userName")).clear();
 driver.findElement(By.name("userName")).sendKeys("user name");
 driver.findElement(By.name("phone")).clear();
 driver.findElement(By.name("phone")).sendKeys("phone number");
 //......
 Thread.sleep(2000);
 //关闭当前窗口
 driver.close();
 }
 }
 Thread.sleep(2000);

 driver.quit();
 }
}

在本例中所涉及的新方法如下：

（十四）下拉框选择

Sat, 17 Jun 2017 12:59:11 +0800

有时我们会碰到下拉框，WebDriver提供了Select类来处理下拉框。如百度搜索设置的下拉框，如下图： ![](http://orru5lls3.bkt.clouddn.com/select.png) ```python from selenium import webdriver from selenium.webdriver.support.select import Select from time import sleep

driver = webdriver.Chrome() driver.implicitly_wait(10) driver.get(‘http://www.baidu.com’)

鼠标悬停至“设置”链接

driver.find_element_by_link_text(‘设置’).click() sleep(1)

打开搜索设置

driver.find_element_by_link_text(“搜索设置”).click() sleep(2)

搜索结果显示条数

sel = driver.find_element_by_xpath("//select[@id=‘nr’]") Select(sel).select_by_value(‘50’) # 显示50条

……

driver.quit()

Select类用于定位select标签。
select_by_value() 方法用于定位下接选项中的value值。




原始封面

![课程图片](https://images.unsplash.com/photo-1431887773042-803ed52bed26?w=300)

requests中如何设置请求的超时时间?

Wed, 22 Nov 2017 03:23:57 +0800

使用timeout 参数可以设定等待连接的秒数，如果等待超时，Requests会抛出异常

>>> requests.get('http://github.com', timeout=0.001)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001)

timeout 仅对连接过程有效，与响应体的下载无关。 timeout 并不是整个下载响应的时间限制，而是如果服务器在 timeout 秒内没有应答，将会引发一个异常（更精确地说，是在 timeout 秒内没有从基础套接字上接收到任何字节的数据时)。

原始封面

（十五）切换窗口(标签)

Mon, 31 Jul 2017 23:49:18 +0800

切换窗口

有时候我们点击链接会弹出新窗口，我们需要去新窗口继续定位和操作元素，这时候就需要用到切换窗口的操作了。

switchTo().window(name_or_handle)方法可以切换到目标窗口。

一般来说，不建议大家直接使用上面的方法去切换，更明智的做法是获取要打开的窗口的链接，然后直接用get访问该链接，这样就不需要写切换窗口的代码了。

switchTo().window(name_or_handle)

该方法的参数有可以是

窗口的name，这是为了兼容以前的实现，至于窗口的name是什么，我不太清楚
窗口句柄，使用driver.getAllWindowHandles()句柄就可以返回浏览器中所有的打开的标签句柄了

目的

学会使用switchTo().window(name_or_handle)方法

示例代码

下面代码演示了如何遍历浏览器所有的标签，并逐一切换过去

dr.getAllWindowHandles().then(function(handles) }{
 for (var i = 0; i < handles.length; i++) {
 dr.switchTo().window(handles[i]);
 }
});

原始封面

（十五）下拉框选择

Mon, 26 Jun 2017 07:37:11 +0800

有时我们会碰到下拉框，WebDriver提供了Select类来处理下接框。

如百度搜索设置的下拉框，如下图：搜索下拉框实现代码如下：

<select id="nr" name="NR">
 <option value="10" selected>每页显示 10 条</option>
 <option value="20">每页显示 20 条</option>
 <option value="50">每页显示 50 条</option>
<select>

操作下接框代码如下：

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;


public class SelectDemo {

 public static void main(String[] args) throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 driver.findElement(By.linkText("设置")).click();
 driver.findElement(By.linkText("搜索设置")).click();
 Thread.sleep(2000);

 //<select>标签的下拉框选择
 WebElement el = driver.findElement(By.xpath("//select"));
 Select sel = new Select(el);
 sel.selectByValue("20");
 Thread.sleep(2000);

 driver.quit();
 }
}

Select类用于定位select标签。 selectByValue()方法符用于选取<option>标签的value值。

（十五）文件上传

Fri, 16 Jun 2017 12:59:11 +0800

对于通过input标签实现的上传功能，可以将其看作是一个输入框，即通过send_keys()指定本地文件路径的方式实现文件上传。

创建upfile.html文件，代码如下：

<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>upload_file</title>
<link href="http://cdn.bootcss.com/bootstrap/3.3.0/css/bootstrap.min.css" rel="stylesheet" />
</head>
<body>
 <div class="row-fluid">
	<div class="span6 well">
	<h3>upload_file</h3>
	 <input type="file" name="file" />
	</div>
 </div>
</body>
<script src="http://cdn.bootcss.com/bootstrap/3.3.0/css/bootstrap.min.js"></scrip>
</html>

通过浏览器打开upfile.html文件，功能如下图。

接下来通过send_keys()方法来实现文件上传。

from selenium import webdriver
import os

driver = webdriver.Firefox()
file_path = 'file:///' + os.path.abspath('upfile.html')
driver.get(file_path)

# 定位上传按钮，添加本地文件
driver.find_element_by_name("file").send_keys('D:\\upload_file.txt')

driver.quit()

原始封面

requests中如何上传文件?

Wed, 22 Nov 2017 03:23:57 +0800

最简单的方式

>>> url = 'http://httpbin.org/post'
>>> files = {'file': open('report.xls', 'rb')}

>>> r = requests.post(url, files=files)
>>> r.text
{
 ...
 "files": {
 "file": "<censored...binary...data>"
 },
 ...
}

你可以显式地设置文件名，文件类型和请求头：

>>> url = 'http://httpbin.org/post'
>>> files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}

>>> r = requests.post(url, files=files)
>>> r.text
{
 ...
 "files": {
 "file": "<censored...binary...data>"
 },
 ...
}

原始封面

（十六）执行javascript

Mon, 31 Jul 2017 02:49:18 +0800

执行javascript

使用driver.executeScript(js)方法会在当前的定位上下文里执行相应的js脚本。

传参

executeScript方法支持向脚本中传入参数，所有参数的参数都可以在脚本中通过arguments对象来引用。我们可以传入下列类型的参数:

boolean
number
string
WebElement:也就是我们定位到的页面对象
Array或者是Object: 只要里面的每一项都是上面的类型就好了

返回值

同样的，我们可以接收js脚本的返回值，返回值有下面一些情况

如果js返回HTML元素，那么该元素会自动被封装成WebElement
null 或者 undefined会被转成null
boolean, number, string 不做转换
function会被转成相应的字符串表示
Array和Object中的每一项都按照上面的规则转换

目的

学会使用executeScript(js)方法
学会向js脚本中传参
学会从js脚本中接收返回值

场景

打开百度首页

先隐藏掉百度一下按钮
然后返回页面上所有导航链接的文本
最后把页面背景变成黑色

代码

var path = require('path');
var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var url = "http://www.baidu.com/";

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get(url)

// 先隐藏掉百度一下按钮
// 通过arguments[0]传入百度一下按钮
var hideBtn = "arguments[0].style.display='none';"

dr.executeScript(hideBtn, dr.findElement(By.id('su')));


// 然后返回页面上所有导航链接的文本
// 通过return返回需要的结果
var linkTexts = "return $('.mnav').text()"
dr.executeScript(linkTexts).then(function(texts) {
 console.log(texts);
});

// 最后把页面背景变成黑色

dr.executeScript("document.body.style.backgroundColor='black'");

运行结果

浏览器

（十六）警告框处理

Sun, 25 Jun 2017 07:37:11 +0800

在 WebDriver中处理JavaScript所生成的alert、confirm以及prompt十分简单，具体做法是使用switch_to_alert()方法定位到alert/confirm/prompt，然后使用text/accept/dismiss/sendKeys等方法进行操作。

getText()：返回 alert/confirm/prompt 中的文字信息。
accept()：接受现有警告框。
dismiss()：解散现有警告框。
sendKeys(keysToSend)：发送文本至警告框。
keysToSend：将文本发送至警告框。

如下图，百度搜索设置弹出的窗口是不能通过前端工具对其进行定位的，这个时候就可以通过switchTo().alert()方法接受这个弹窗。

接受一个警告框的代码如下：

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;


public class AlertDemo {

 public static void main(String[] args) throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 driver.findElement(By.linkText("设置")).click();
 driver.findElement(By.linkText("搜索设置")).click();
 Thread.sleep(2000);

 //保存设置
 driver.findElement(By.className("prefpanelgo")).click();

 //接收弹窗
 driver.switchTo().alert().accept();
 Thread.sleep(2000);

 driver.quit();
 }
}

原始封面

（十六）cookie操作

Thu, 15 Jun 2017 12:59:11 +0800

有时候我们需要验证浏览器中cookie是否正确，因为基于真实cookie的测试是无法通过白盒和集成测试进行的。WebDriver提供了操作Cookie的相关方法，可以读取、添加和删除cookie信息。

WebDriver操作cookie的方法：

get_cookies()：获得所有cookie信息。
get_cookie(name)：返回字典的key为“name”的cookie信息。
add_cookie(cookie_dict) ：添加cookie。“cookie_dict”指字典对象，必须有name 和value 值。
delete_cookie(name,optionsString)：删除cookie信息。“name”是要删除的cookie的名称，“optionsString”是该cookie的选项，目前支持的选项包括“路径”，“域”。
delete_all_cookies()：删除所有cookie信息。

下面通过get_cookies()来获取当前浏览器的cookie信息。

from selenium import webdriver

driver = webdriver.Firefox()
driver.get("http://www.youdao.com")

# 获得cookie信息
cookie= driver.get_cookies()
# 将获得cookie的信息打印
print(cookie)

driver.quit()

从执行结果可以看出，cookie数据是以字典的形式进行存放的。知道了cookie的存放形式，接下来我们就可以按照这种形式向浏览器中写入cookie信息。

from selenium import webdriver

driver = webdriver.Firefox()
driver.get("http://www.youdao.com")

# 向cookie的name 和value中添加会话信息
driver.add_cookie({'name': 'key-aaaaaaa', 'value': 'value-bbbbbb'})

# 遍历cookies中的name 和value信息并打印，当然还有上面添加的信息
for cookie in driver.get_cookies():
 print("%s -> %s" % (cookie['name'], cookie['value']))

driver.quit()


输出结果：
======================== RESTART: =========================
YOUDAO_MOBILE_ACCESS_TYPE -> 1
_PREF_ANONYUSER__MYTH -> aGFzbG9nZ2VkPXRydWU=
OUTFOX_SEARCH_USER_ID -> -1046383847@218.17.158.115
JSESSIONID -> abc7qSE_SBGsVgnVLBvcu
key-aaaaaaa -> value-bbbbbb

从执行结果可以看到，最后一条cookie信息是在脚本执行过程中通过add_cookie()方法添加的。通过遍历得到所有的cookie信息，从而找到key为“name”和“value”的特定cookie的value。

原始封面

（十七）alert confirm 和 prompt

Mon, 31 Jul 2017 01:49:18 +0800

alert confirm prompt

原生的javascript弹出框，各个浏览器的实现不一样，外观也不太一样。

这些弹出框会阻止页面上的所有操作，因此每次这些框弹出来以后，我们必须想办法让这些东西消失掉，否则脚本无法往下进行下去。

一般的处理方式

当alert弹出之后，我们可以通过类似下面的代码去处理alert

driver.switchTo().alert().dismiss();
driver.switchTo().alert().accept();

切换到alert/confirm/prompt之后，我们可以进行如下的后续动作

accept(): 接受,点ok
dismiss(): 点取消
getText(): 拿到提示文本
sendKeys( text ): 如果是prompt的话，可以用该方法输入一些内容
authenticateAs( username, password ): 如果是basic authentication的话，可以通过该方法来输入用户名和密码

一劳永逸的处理方式

如果我们不在乎alert上提示的内容，只想页面上不弹出alert/confirm/prompt的话，可以通过js来覆盖这些方法的原生实现，从而达到禁用弹出框的效果，比如下面的代码就演示了如何禁用alert。

var banAlert = 'window.alert = function(msg){}'
driver.executeScript(banAlert);

这样在测试过程中，所有的alert都不会弹出。

原始封面

（十七）文件上传

Sat, 24 Jun 2017 07:37:11 +0800

对于通过input标签实现的上传功能，可以将其看作是一个输入框，即通过sendKeys()指定本地文件路径的方式实现文件上传。

创建upfile.html文件，代码如下：

<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>upload_file</title>
<link href="http://cdn.bootcss.com/bootstrap/3.3.0/css/bootstrap.min.css" rel="stylesheet" />
</head>
<body>
 <div class="row-fluid">
	<div class="span6 well">
	<h3>upload_file</h3>
	 <input type="file" name="file" />
	</div>
 </div>
</body>
<script src="http://cdn.bootcss.com/bootstrap/3.3.0/css/bootstrap.min.js"></scrip>
</html>

通过浏览器打开upfile.html文件，功能如下图。

接下来通过sendKeys()方法来实现文件上传。

import java.io.File;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;


public class UpFileDemo {

 public static void main(String[] args) throws InterruptedException {

 WebDriver driver = new ChromeDriver();
 File file = new File("./HTMLFile/upfile.html");
 String filePath = file.getAbsolutePath();
 driver.get(filePath);

 //定位上传按钮， 添加本地文件
 driver.findElement(By.name("file")).sendKeys("D:\\upload_file.txt");
 Thread.sleep(5000);

 driver.quit();
 }
}

原始封面

（十七）调用JavaScript代码

Wed, 14 Jun 2017 12:59:11 +0800

虽然WebDriver提供了操作浏览器的前进和后退方法，但对于浏览器滚动条并没有提供相应的操作方法。在这种情况下，就可以借助JavaScript来控制浏览器的滚动条。WebDriver提供了execute_script()方法来执行JavaScript代码。

用于调整浏览器滚动条位置的JavaScript代码如下：

<!-- window.scrollTo(左边距,上边距); -->
window.scrollTo(0,450);

window.scrollTo()方法用于设置浏览器窗口滚动条的水平和垂直位置。方法的第一个参数表示水平的左间距，第二个参数表示垂直的上边距。其代码如下：

from selenium import webdriver
from time import sleep

# 访问百度
driver=webdriver.Firefox()
driver.get("http://www.baidu.com")

# 设置浏览器窗口大小
driver.set_window_size(500, 500)

# 搜索
driver.find_element_by_id("kw").send_keys("selenium")
driver.find_element_by_id("su").click()
sleep(2)

# 通过javascript设置浏览器窗口的滚动条位置
js="window.scrollTo(100,450);"
driver.execute_script(js)
sleep(3)

driver.quit()

通过浏览器打开百度进行搜索，并且提前通过set_window_size()方法将浏览器窗口设置为固定宽高显示，目的是让窗口出现水平和垂直滚动条。然后通过execute_script()方法执行JavaScripts代码来移动滚动条的位置。

原始封面

（十八）截图

Sun, 30 Jul 2017 02:49:18 +0800

截图

在测试用例失败的时候进行截图，这是大家经常会遇到的需求。

目的

学会使用takeScreenshot()方法

场景

下面我们就用代码实现打开测试教程网 selenium javascript教程，然后截图的功能

代码

var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var Key = webdriver.Key;

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get('http://www.testclass.net/selenium_javascript/');
dr.takeScreenshot().then(function(data) {
 require('fs').writeFile('pic.png', data, 'base64');
 dr.quit();
})

运行结果

脚本目录下会出现pic.png文件。

原始封面

（十八）浏览器cookie操作

Fri, 23 Jun 2017 07:37:11 +0800

有时候我们需要验证浏览器中Cookie是否正确，因为基于真实Cookie的测试是__无法通过白盒测试和集成测试进行的__。WebDriver提供了操作Cookie的相关方法可以读取、添加和删除Cookie信息。

WebDriver 操作Cookie的方法：

getCookies() 获得所有 cookie 信息。
getCookieNamed(String name) 返回字典的key为“name”的Cookie信息。
addCookie(cookie dict) 添加Cookie。“cookie_dict”指字典对象，必须有 name和value值。
deleteCookieNamed(String name) 删除Cookie 信息。 “name”是要删除的 cookie的名称； “optionsString” 是该Cookie的选项，目前支持的选项包括“路径” ， “域” 。
deleteAllCookies() 删除所有 cookie 信息。

下面通过 geCookies()来获取当前浏览器的 cookie 信息。

import java.util.Set;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.Cookie;


public class CookieDemo {

 public static void main(String[] args){

 WebDriver driver = new ChromeDriver();
 driver.get("https://www.baidu.com");

 Cookie c1 = new Cookie("name", "key-aaaaaaa");
 Cookie c2 = new Cookie("value", "value-bbbbbb");
 driver.manage().addCookie(c1);
 driver.manage().addCookie(c2);

 //获得 cookie
 Set<Cookie> coo = driver.manage().getCookies();
 System.out.println(coo);

 //删除所有 cookie
 //driver.manage().deleteAllCookies();

 driver.quit();
 }
}

打印结果：

（十八）窗口截图

Tue, 13 Jun 2017 12:59:11 +0800

自动化用例是由程序去执行的，因此有时候打印的错误信息并不十分明确。如果在脚本执行出错的时候能对当前窗口截图保存，那么通过图片就可以非常直观地看出出错的原因。WebDriver提供了截图函数get_screenshot_as_file()来截取当前窗口。 ```python from selenium import webdriver from time import sleep

driver = webdriver.Firefox() driver.get(‘http://www.baidu.com’)

driver.find_element_by_id(‘kw’).send_keys(‘selenium’) driver.find_element_by_id(‘su’).click() sleep(2)

截取当前窗口，并指定截图图片的保存位置

driver.get_screenshot_as_file(“D:\baidu_img.jpg”)

driver.quit()

脚本运行完成后打开D盘，就可以找到baidu_img.jpg图片文件了。




原始封面

![课程图片](https://images.unsplash.com/photo-1513836279014-a89f7a76ae86?w=300)

（十九）wait和sleep

Sat, 29 Jul 2017 02:48:18 +0800

wait( condition, opt_timeout, opt_message )

wait方法一般用来等待页面上某些条件得到满足后才继续执行脚本。比如等待页面上某个弹出框出现，等某个元素可以被定位到之类。

wait方法中可以传入Condition表示一般性条件和WebElementCondition。

如果传入的元素级条件被满足，那么wait方法会返回 WebElementPromise，也就是说可以直接返回满足条件的元素。

如果在规定的时间内(也就是第2个参数)没有等到条件被满足，那么该方法会抛出异常。

一般性用法示例：

// 在10s内id是foo的元素被定位到，然后点击之
var button = driver.wait(until.elementLocated(By.id('foo')), 10000);
button.click();

另外wait还可以将执行中的脚本暂停住一段时间，直到第1个参数中的异步操作处理完毕，如下所示

var started = startTestServer();
driver.wait(started, 5 * 1000, 'Server should start within 5 seconds');
driver.get(getServerUrl());

sleep

sleep可以不管任何情况直接将执行中的脚本直接暂停一段时间。

console.log('start')
driver.findElement(By.css('.kls')).click();
// 等待3s
driver.sleep(3000)
driver.quit()

sleep在某些时候非常好用，但是希望大家不要乱用，因为这会拖慢脚本的执行速度。

原始封面

（十九）调用JavaScript代码

Thu, 22 Jun 2017 07:37:11 +0800

虽然WebDriver提供了操作浏览器的前进和后退方法，但对于浏览器滚动条并没有提供相应的操作方法。在这种情况下，就可以借助JavaScript来控制浏览器的滚动条。WebDriver提供了executeScript()方法来执行JavaScript代码。

用于调整浏览器滚动条位置的JavaScript代码如下：

<!-- window.scrollTo(左边距,上边距); -->
window.scrollTo(0,450);

window.scrollTo()方法用于设置浏览器窗口滚动条的水平和垂直位置。方法的第一个参数表示水平的左间距，第二个参数表示垂直的上边距。其代码如下：

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.JavascriptExecutor;

public class JSDemo {

 public static void main(String[] args) throws InterruptedException{

 WebDriver driver = new ChromeDriver();

 //设置浏览器窗口大小
 driver.manage().window().setSize(new Dimension(700, 600));
 driver.get("https://www.baidu.com");

 //进行百度搜索
 driver.findElement(By.id("kw")).sendKeys("webdriver api");
 driver.findElement(By.id("su")).click();
 Thread.sleep(2000);

 //将页面滚动条拖到底部
 ((JavascriptExecutor)driver).executeScript("window.scrollTo(100,450);");
 Thread.sleep(3000);

 driver.quit();
 }
}

通过浏览器打开百度进行搜索，并且提前通过window().setSize()方法将浏览器窗口设置为固定宽高显示，目的是让窗口出现水平和垂直滚动条。然后通过executeScript()方法执行JavaScripts代码来移动滚动条的位置。

（十九）关闭浏览器

Mon, 12 Jun 2017 12:59:11 +0800

在前面的例子中我们一直使用quit()方法，其含义为退出相关的驱动程序和关闭所有窗口。除此之外，WebDriver还提供了close()方法，用来关闭当前窗口。例多窗口的处理，在用例执行的过程中打开了多个窗口，我们想要关闭其中的某个窗口，这时就要用到close()方法进行关闭了。

close() 关闭单个窗口
quit() 关闭所有窗口

原始封面

JMeter官方文档：20. 函数

Thu, 24 Aug 2017 06:05:11 +0800

《JMeter官方文档–翻译计划》原文地址

20. 函数和变量

JMeter 的函数是一些特殊值，它们可以填充在测试树的任何采样器或其他元件中。函数调用的语法如下：

${__functionName(var1,var2,var3)}

其中“__functionName” 匹配函数的名称。
圆括号内为函数参数，不同函数的参数也不同，例如 ${__time(YMD)}。没有参数的函数可以不需要圆括号，例如 ${__threadNum}。

如果函数的参数包含逗号，需要加上“\”来转义，否则 JMeter 会把逗号当做参数的分隔符。例如：

${__time(EEE\, d MMM yyyy)}

如果逗号没有被转义——例如 ${__javaScript(Math.max(2,5))} ——你会得到像这样的错误信息：

ERROR - jmeter.functions.JavaScript: Error processing Javascript: [Math.max(2]
org.mozilla.javascript.EvaluatorException: missing ) after argument list (<cmd>#1)

这是因为字符串“Math.max(2,5)”被当做__javascript 函数的两个参数：
Math.max(2 和 5)
其他错误信息也是有可能的。

变量的引用如下：

${VARIABLE}

如果引用了未定义的变量或函数，那么 JMeter 并不会报告或者记录错误信息——引用返回值就是引用自身。例如，如果 UNDEF 没有被定义为变量，${UNDEF} 的返回值就是 ${UNDEF}。变量和函数（包括属性）都是区分大小写的。JMeter 会剔除变量名称中的空格，例如 ${__Random(1,63, LOTTERY )} 中的变量‘　LOTTERY 　’会被‘LOTTERY’取代。

属性与变量不一样。变量对线程而言是局部的；属性是针对所有线程的，属性需要使用 __P 或 __property 函数来引用。

在 Windows 路径变量（例如 C:\test\${test}）前使用 \ 时，要确保加上 \ 来转义，否则 JMeter 将不能解释变量，所以要这样写：C:\\test\\${test}。
还有一种方法，就是使用 / 作为路径分隔符，例如 C:/test/${test}——Windows 的 Java 虚拟机在必要时会将它转换成路径分隔符。

（二十）until

Thu, 27 Jul 2017 02:49:18 +0800

until

until一般跟wait一起用，用于等待页面上的一些条件被满足

条件一览

ableToSwitchToFrame(frame): 直到selenium可以将定位上下文切换到frame里
alertIsPresent(): 直到alert出现
elementIsDisabled(element): 直到元素灰掉，不能被点击
elementIsEnabled(element): 直到元素可以被点击
elementIsNotSelected(element): 直到元素不可选
elementIsNotVisible(element): 直到元素不可见
elementIsSelected(element): 直到元素可选
elementIsVisible(element): 直到元素可见
elementLocated(locator): 最常用，直到元素可以被定位
elementTextContains(element, substr): 直到元素的text包含substr
elementTextIs(element, expected_text): 直到元素的text是expected_text
elementTextMatches(element,regex): 直到元素的text满足正则表达式regex
elementsLocated(locator): 直到一组元素被定位
stalenessOf(element): 直到元素被dom树移除或页面刷新
titleContains(substr): 直到页面title包含substr
titleIs(expected_title): 直到页面的title是expected_title
titleMatches(regex): 直到页面的title满足正则表达式regex
urlContains(substrUrl): 直到页面url包含substrUrl
urlIs(expected_url): 直到页面的url是expected_url
urlMatches(regex): 直到页面的url满足正则表达式regex

自定义条件

until还允许我们自定义条件。我们只需要传入1个回调，该回调返回真值(true)就代表等待的条件被满足。

在javascript，真值表示所有不是null, undefined, false, 0, 或空字符串的值。

driver.wait(function() {
 return driver.getTitle().then(function(title) {
 return title === '测试教程网';
 });
}, 1000);

原始封面

（二十）获取窗口截图

Wed, 21 Jun 2017 07:37:11 +0800

自动化用例是由程序去执行，因此有时候打印的错误信息并不十分明确。如果在脚本执行出错的时候能对当前窗口截图保存，那么通过图片就可以非常直观地看出出错的原因。 WebDriver提供了截图函数getScreenshotAs()来截取当前窗口。 ```java import java.io.File; import java.io.IOException; import org.apache.commons.io.FileUtils; import org.openqa.selenium.OutputType; import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; import org.openqa.selenium.TakesScreenshot;

public class GetImg {

public static void main(String[] arge){

WebDriver driver = new ChromeDriver();
driver.get("https://www.baidu.com");

File srcFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
try {
 FileUtils.copyFile(srcFile,new File("d:\\screenshot.png"));
} catch (IOException e) {
 e.printStackTrace();
}

driver.quit();

} }

脚本运行完成后打开D盘，就可以找到screenshot.png图片文件了。




原始封面

![课程图片](https://images.unsplash.com/photo-1527689368864-3a821dbccc34?w=300)

JMeter官方文档：21. 正则表达式

Thu, 24 Aug 2017 05:59:11 +0800

《JMeter官方文档–翻译计划》原文地址

21. 正则表达式

21.1 概述

JMeter 包含模式匹配软件 Apache Jakarta ORO 。
在 Jakarta 网上有一些关于它的文档，例如：模式匹配字符摘要。

在 OROMatcher 用户指南上还有一个关于该产品旧版本的文档，也许会有些用处。

模式匹配与 Perl 中的模式匹配非常类似。Perl 的完整安装会包含大量关于正则表达式的文档——查找 perlrequick， perlretut， perlre 和 perlreref。

有必要强调“包含（contains）”和“匹配（matches）”之间的区别，它们被用在响应断言测试原件上：

“包含（contains）” 意味着正则表达式至少与目标的某个部分相匹配，所以 ‘alphabet’ “包含” ‘ph.b.’，因为正则表达式匹配子字符串 ‘phabe’。

“匹配（matches）” 意味着正则表达式匹配整个目标。所以 ‘alphabet’ 和 ‘al.*t’ 是“匹配”的。
这种情况下，它相当于将正则表达式封装在 ^ 和 $ 中，即 ‘^al.*t$’。

然而，情况并非总是如此。例如，正则表达式 ‘alp|.lp.*’ “包含”于 ‘alphabet’，但并不“匹配” ‘alphabet’。

这是为什么？原因是当模式匹配器在 ‘alphabet’ 中找到序列 ‘alp’ 时，它将停止尝试其他组合——而 ‘alp’ 与 ‘alphabet’ 不同，它不包含 ‘habet’。

不同于 Perl，没有必要将正则表达式用 // 封装。

（二十一）断言

Thu, 20 Jul 2017 02:49:18 +0800

测试用例与断言

测试用例中至少需要包含1个断言，没有断言的测试脚本不能称为测试用例。

断言就是预期和实际的比较，如果预期不等于实际，脚本将会报错。

selenium 自带断言

selenium 自带了一些断言，具体看断言。

场景

我们下面实现打开测试教程网并做2个断言

页面title包含测试教程网几个字
页面url包含testclass几个字

代码

var webdriver = require('selenium-webdriver'),
 By = webdriver.By;

var assert = require('selenium-webdriver/testing/assert');

var dr = new webdriver.Builder().forBrowser('chrome').build();
dr.get('http://www.testclass.net/');

dr.getTitle().then(function(title) {
 assert(title).contains('测试教程网');
});

dr.getCurrentUrl().then(function(url) {
 assert(url).contains('testclass');
});

dr.quit()

运行结果

上面断言全部通过的时候看不到任何的结果，大家可以试着修改一下断言，让断言失败，这时候就应该可以看到类似下面的信息

AssertionError: 测试教程网 · 测试教程网.indexOf(测试教程网12443) !== -1

测试框架

在做真实的测试时，我们一般会用测试框架配合selenium一起来实现复杂的场景测试和测试报告的生成，在这里向大家推荐一些测试框架

mocha: 强烈推荐，灵活简单，可以配合selenium断言一起用
qunit: 简单好用
jest: facebook出品，大树底下好乘凉
tape: 足够简单

原始封面

（一）JMeter介绍与安装

Sun, 30 Jul 2017 12:59:11 +0800

#### Jmeter介绍 ---- Apache JMeter™应用开源软件，100%纯Java应用程序,设计用于负载功能测试和性能测试。它最初是为测试Web应用程序而设计的，但后来扩展到其他测试函数中。

Apache JMeter 功能包括:

能够加载和测试许多不同的应用程序/服务器/协议类型：
- Web的HTTP，HTTPS（java，Nodejs，PHP，ASP.NET，…）
- SOAP / REST Webservices
- FTP 文件传输协议
- Database via JDBC
- LDAP
- Message-oriented middleware (MOM) via JMS
- 邮件传输协议 - SMTP(S), POP3(S) 和 IMAP(S)
- 本地命令或Shell 脚本
- TCP
- Java Objects
全功能测试IDE，允许快速记录测试计划（来自浏览器或本地应用程序），构建和调试。
基于Java开发，支持Linux、Windows、MAC OSX等平台。
可以生成完整的动态HTML报告。
通过从最流行的响应格式、HTML、JSON、XML或任何文本格式提取数据的能力，可以轻松地进行相关性。
全多线程框架允许多线程并发采样，同时通过不同的线程组进行不同功能的同时采样。
缓存和离线分析/重放测试结果。
高度可扩展内核。

#### Jmeter安装 ---- 前面已经介绍了Jmeter是基于Java开发的，它的运行同样依赖于Java环境。

1、首先，安装Java。

2、然后，下载Jmeter。

3、解压下载的__apache-jmeter-3.2.zip__包.

4、进入…\apache-jmeter-3.2\bin\解压目录，双击__ApacheJMeter.jar__启动（注：一定要配置Java环境）。

如果可以看到上图，说明你的Jmeter已经安装好了。

原始封面

（二）JMeter插件管理

Sat, 29 Jul 2017 12:59:11 +0800

#### Jmeter插件管理 ---- JMeter 插件管理器的使用方法很简单：不要手动安装各种插件，它提供了友好的用户界面来完成：安装、升级、卸载。

它管理插件包括 jmeter-plugins.org 上面常用的插件，和各种第三方插件甚至核心JMeter插件。

#### 安装插件管理： ---- 1、下载 [plugins-manager.jar](http://www.jmeter-plugins.org/get/)

2、将 plugins-manager.jar 放到 _…\apache-jmeter-3.2\lib\ext_ 目录下。

3、双击 ApacheJMeter.jar 启动Jmeter。

4、菜单栏“选项”会多出一个“Plugins Manager”的选项。

点击 “Plugins Manager” 选项打开 Jmeter 插件管理

插件管理窗口分三个标签页：

Installed Plugins：显示已安装的插件。
Available Plugins: 显示可安装的插件。
Upgrades: 显示可以升级的插件。

通过__勾选/取消勾选__插件，并点击右下角 “Apply Changes and Restart JMeter” 按钮来__卸载、安装、升级__插件。

原始封面

（三）JMeter录制与回放

Fri, 28 Jul 2017 12:59:11 +0800

### 关于录制和回放功能

在JMeter2.1版本之前，JMeter应该是不支持录制和回放功能的，那时候如果需要录制jmeter的性能测试脚本的话，就需要使用第三方工具——badboy。

现在jmeter已经支持脚本的录制功能了，但录制的体验相对于badboy来说还是差了一些。不过聊胜于无，对于性能测试的入门者来说，录制回放功能可以让大家对性能测试脚本开发的过程有个非常感性的认识。

不过录制脚本始终只是减轻工作量的一个手段，新手同学千万不要认为学会了录制回放就等于是学会了性能测试，学会录制回放只能代表你有机会真正的入门性能测试，这只是起点，而不是终点。

测试场景

在本节中，我们的测试场景是：在必应(bing)搜索引擎中搜索关键字乙醇 selenium。我们对搜索的结果并不关心，只要请求返回的状态码是200，我们就认为该请求是成功的，有效的。

准备录制

打开jmeter
工具栏点击Templates… ，选择Recording模版
点击WorkBench节点下的HTTP(S) Test Script Recorder
点击启动按钮，如下图所示

此时应该会出现下图所示的警告对话框，我们可以简单的忽略掉，此警告不影响我们本节内容的准确性

完成了以上的步骤之后，我们就成功的启动了jmeter的http代理，下面我们需要对配置系统，使得系统的http请求都通过jmeter代理发出。

注意：如果启动代理的过程中遇到了一些意外情况，请参考这里解决

### 配置HTTP代理 ---- #### Mac OS 系统

系统偏好设置 -> 网络 -> 代理 -> Web代理(HTTP)
web代理服务器填写localhost，端口填写8888，如下图所示

保存配置

Windows 系统

Windows 10

（四）创建一个简单的性能测试

Mon, 24 Jul 2017 12:59:11 +0800

请先参考[Jmeter介绍与安装](/jmeter/install-jmeter/) ，启动Jmeter。

建立测试计划启动jmeter后，jmeter会自动生成一个空的测试计划，用户可以基于该测试计划建立自己的测试计划。

#### 添加线程组 ---- 一个性能测试请求负载是基于一个线程组完成的。一个测试计划必须有一个线程组。测试计划添加线程组非常简单。在测试计划右键弹出下拉菜单（添加-->Threads(Users)--->线程组）中选择线程组即可。

jmeter中每个测试计划至少需要包含一个线程组，当然也可以在一个计划中创建多个线程组，那么多个线程组之间又会怎样的顺序执行（串行还是并行）？在测试计划下面多个线程是并行执行的，也就是说这些线程组是同时被初始化并同时执行线程组下的Sampler的。

线程组主要包含三个参数：线程数、准备时长（Ramp-Up Period(in seconds)）、循环次数。

线程数： 虚拟用户数。一个虚拟用户占用一个进程或线程。设置多少虚拟用户数在这里也就是设置多少个线程数。

准备时长： 设置的虚拟用户数需要多长时间全部启动。如果线程数为20 ，准备时长为10 ，那么需要10秒钟启动20个线程。也就是每秒钟启动2个线程。

循环次数: 每个线程发送请求的次数。如果线程数为20 ，循环次数为100 ，那么每个线程发送100次请求。总请求数为20*100=2000 。如果勾选了“永远”，那么所有线程会一直发送请求，直到选择停止运行脚本。

设置合理的线程数对于能否达到测试目标有决定性的影响。除了上面介绍的固定循环次数与永远外；也可以灵活的选择设定测试运行时间。勾选“调度器”，进行调度器配置。

设置：线程数为10，其它参数默认。

#### 添加HTTP请求 ---- 添加完成线程组后，在线程组上右键菜单（添加--->Sampler--->HTTP请求）选择HTTP请求。对于jmeter来说，取样器（Sampler）是与服务器进行交互的单元。一个取样器通常进行三部分的工作： ``` 1、向服务器发送请求

2、记录服务器的响应数据

3、记录响应时间信息


![](http://img.testclass.net/add_http.png)

![](http://img.testclass.net/http_request.png)

一个HTTP请求有着许多的配置参数，下面将详细介绍：

__名称：__ 本属性用于标识一个取样器，建议使用一个有意义的名称。

__注释：__ 对于测试没有任何作用，仅用户记录用户可读的注释信息。

__服务器名称或IP ：__ HTTP请求发送的目标服务器名称或IP地址。

__端口号：__ 目标服务器的端口号，默认值为80 。

__协议：__ 向目标服务器发送HTTP请求时的协议，可以是http或者是https ，默认值为http 。

__方法：__ 发送HTTP请求的方法，可用方法包括GET、POST、HEAD、PUT、OPTIONS、TRACE、DELETE等。

__Content encoding ：__ 内容的编码方式，默认值为iso8859

__路径：__ 目标URL路径（不包括服务器地址和端口）

__自动重定向：__ 如果选中该选项，当发送HTTP请求后得到的响应是302/301时，JMeter 自动重定向到新的页面。

__Use keep Alive ：__ 当该选项被选中时，jmeter 和目标服务器之间使用 Keep-Alive方式进行HTTP通信，默认选中。

__Use multipart/from-data for HTTP POST ：__ 当发送HTTP POST 请求时，使用Use multipart/from-data方法发送，默认不选中。

* 在这里我们添加一个HTTP请求: http://www.testclass.net

<br>
#### 添加监听器（Listener）
----

脚本的主要部分设置完成后，需要通过某种方式获得性能测试中的测试结果，在本例中，我们关心的是请求的响应时间。

Jmeter 中使用监听器元件收集取样器记录的数据并以可视化的方式来呈现。Jmeter有各种不同的监听器类型，因为上面添加的为HTTP请求，这里添加聚合报告，更为直观的查看测试结果。

添加聚合报告，右键点击线程组，在弹的菜单（添加--->监听器--->聚合报告）中选择聚合报告。

![](http://img.testclass.net/add_report.png)

点击工具栏上的 ```绿色运行按钮``` 或者通过菜单栏（运行--->启动）来运行测试。

查看 __"聚合报告"__ 的运行结果：

![](http://img.testclass.net/test_report.png)

__Label：__ 请求的名称，就是我们在进行测试的httprequest sampler的名称

__Samples：__ 总共发给服务器的请求数量

__Average：__ 单个请求的平均响应时间，单位是毫秒

__Median：__ 50%的请求的响应时间

__90%Line：__ 90%的请求的响应时间

__95%Line：__ 95%的请求的响应时间

__99%Line：__ 99%的请求的响应时间

__Min：__ 最小的响应时间

__Max：__ 最大的响应时间

__Error%：__ 错误率=错误的请求的数量/请求的总数

__Throughput：__ 吞吐量即表示每秒完成的请求数

__Received KB/sec：__ 每秒从服务器端接收到的数据量

__Sent KB/Sec：__ 每秒从发送到服务器端的数据量

<br>
到此，一个简单的性能测试完成了。




原始封面

![课程图片](https://images.unsplash.com/photo-1508081803367-63a3f657e987?w=300)

（五）JMeter基础元件介绍

Sun, 23 Jul 2017 12:59:11 +0800

### 测试计划 ----

Test Plan (测试计划)

用来描述一个性能测试，包含与本次性能测试所有相关的功能。也就说JMeter创建性能测试的所有内容是于基于一个计划的。

下面看看一个计划下面都有哪些功能模块（右键单击“测试计划”弹出菜单）。

Threads （Users）线程用户

虽然有三个添加线程组的选项，名字不一样，创建之后，其界面是完全一样的。在Jmeter之前的版本只有一个线程组的名字。现在多一个 setUp theread Group 与 tearDown Thread Group

setup thread group

一种特殊类型的ThreadGroup的，可用于执行预测试操作。这些线程的行为完全像一个正常的线程组元件。不同的是，这些类型的线程执行 测试前 进行定期线程组的执行。

teardown thread group

一种特殊类型的ThreadGroup的，可用于执行测试后动作。这些线程的行为完全像一个正常的线程组元件。不同的是，这些类型的线程执行 测试结束后 进行定期的线程组。

可能你还是不太理解他们与普通的线程组有什么不同。如果您用过Junit单元测试框架，想必你不会对setUp(before) ，tearDown(after) 这两个关键字不陌生。即使没用过，也没关系。熟悉loadrunner的应该知道，loadrunner的脚本除了action里是真正的脚本核心内容，还有初始化“环境”的初始化脚本和测试完毕后对应的清除信息的脚本块。那么这里 setup thread group 和 teardown thread group 就是分别指这两部分。其实从本质上来看，他们并没有什么不同。

thread group(线程组)

这个就是我们通常添加运行的线程。通俗的讲一个线程组，可以看做一个虚拟用户组，线程组中的每个线程都可以理解为一个虚拟用户。线程组中包含的线程数量在测试执行过程中是不会发生改变的。

测试片段（Test Fragment）

（六）JMeter元件的作用域与执行顺序

Sun, 23 Jul 2017 12:59:11 +0800

### 元件的作用域 ---- 先来讨论一下元件有作用域。《[JMeter基础元件介绍](/jmeter/base-element/)》一节中，我们介绍了8类可被执行的元件（测试计划与线程组不属于元件），这些元件中，__取样器__ 是典型的不与其它元件发生交互作用的元件，__逻辑控制器__ 只对其子节点的取样器有效，而其它元件（config elements 、timers 、post-processors、assertions、listeners）需要与取样器（sampler）等元件交互。

配置元件（config elements）

元件会影响其作用范围内的所有元件。

前置处理程序（Per-processors）

元件在其作用范围内的每一个sampler元件之前执行。

定时器（timers ）

元件对其作用范围内的每一个sampler有效。

后置处理程序（Post-processors）

元件在其作用范围内的每一个sampler元件之后执行。

断言（Assertions）

元件对其作用范围内的每一个sampler元件执行后的结果执行校验。

监听器（Listeners）

元件收集其作用范围的每一个sampler元件的信息并呈现。

在JMeter中，元件的作用域是靠测试计划的的树型结构中元件的父子关系来确定的，作用域的原则是：

取样器（sampler）元件不和其它元件相互作用，因此不存在作用域的问题。
逻辑控制器（Logic Controller）元件只对其子节点中的取样器和逻辑控制器作用。
除取样器和逻辑控制器元件外，其他6类元件，如果是某个sampler的子节点，则该元件会对其父子节点起作用。
除取样器和逻辑控制器元件外，其他6类元件，如果其父节点不是sampler ，则其作用域是该元件父节点下的其他所有后代节点（包括子节点，子节点的子节点等）。

讲了这些，你可能迷糊了，到底是肿么个情况呀！？通过两个栗子（例子）来理解一下他们的作用域。

例一

注：下图只是为了说明作用域，无法正常运行。

取样器： HTTP请求、FTP请求、TCP取样器；逻辑控制器： 循环控制器；监听器： 图形结果、聚合报告。

HTTP请求、FTP请求、TCP取样器元件没有作用域的概念。
循环控制器元件作用域是其子节点FTP请求、TCP取样器。
图形结果元件的作用域是FTP请求、TCP取样器。
聚合报告元作的作用域是HTTP请求、FTP请求、TCP取样器。

例二

注：下图只是为了说明作用域，无法正常运行。

（七）JMeter基础知识点：参数化

Sat, 22 Jul 2017 12:59:11 +0800

### 参数化 ---- 简单的来理解一下，我们录制了一个脚本，这个脚本中有登录操作，需要输入用户名和密码，假如系统不允许相同的用户名和密码同时登录，或者想更好的模拟多个用户来登录系统。

这个时候就需要对用户名和密码进行参数化，使每个虚拟用户都使用不同的用户名和密码进行访问。

前提需求：

我们有一个嘉宾管理系统，该系统需要登录。

在Jmeter中添加一个登录HTTP请求，设置登录的用户名和密码。如下：

配置参数：

* 协议：http
* IP（网址）：127.0.0.1
* 端口号：8000
* 请求方法：POST
* 请求路径：/login_action/
* 自动重定向
* 同请求一起发送参数: username=admin, password=admin123456

#### 设置参数化

第一步：

我们需要“参数化”的数据，这里我用CSV格式的文件创建了五个用户名/密码，保存为.csv格式的文件。

将文件放在：D:\login_user.csv 。关于如何得到成百上千的用户名和密码，可以使用SQL语句在数据库中创建，并将数据导出保存，这里就不深究。

第二步：

好，我们要编写函数来调用这个login_user.csv文件，点击菜单栏“选项”—->“函数助手对话框”，如下图。

注：.csv文件第一列从0开始取得。

（八）JMeter基础知识点：检查点

Sat, 22 Jul 2017 12:59:11 +0800

### 检查点 ---- 检查点不是太专的叫法，不管是在自动化测试还是性能测试工具中，应该叫：__断言__

简单的来理解一下，在《JMeter基础知识点：参数化》中，我们对用户名和密码进行了参数化，那么怎样来判断JMeter参数化的用户有没真正的登录成功呢？或者有没有返回登录成功的页面。这就需要用到断言了。

前提需求：

我们有一个嘉宾管理系统，该系统登录成功的页面。

#### 添加断言 ----

第一步

右键点击“HTTP请求”—->添加—->断言—->响应断言。

第二步

打开响应断言，进行设置。

要测试的响应字段： 响应文本、Document(text)、URL样本、响应信息、Response Headers、Lgnore Staus 等选项。虽然接口返回的是HTML页面，但对于JMeter来说返回数据为文本，所以，这里可以勾选“响应文本”。

模式匹配规则： 包括、匹配、 Equals、 Substring。这里只需要验证返回数据中是否包含主要的关键字，所以，这里勾选“包括” 。

要测试的模式： 其实就是断言的数据。点击“添加” 按钮，输入要断言的数据。

我们怎么证明登录是成功的？肯定是从登录成功的页面上抓取信息来判断了。那么，Guest Manage System 和退出看来不错，因为只有登录成功的页面上才有。

（九）JMeter基础知识点：集合点

Sat, 22 Jul 2017 12:59:10 +0800

### 集合点 ----

简单来理解一下，虽然我们的“性能测试”理解为“多用户并发测试”，但真正的并发是不存在的，为了更真实的实现并发的操作，我们可以在需要压力的地方设置集合点。

关联阅读：《JMeter基础知识点：参数化》《JMeter基础知识点：检查点》

还拿前面用户和密码的功能，每到输入用户名和密码登录的地方，所有的虚拟用户都相互之间等一等，然后一起访问。（连长说一声令下，大家一起冲啊！这样给敌人的压力会很大。）

第一步

接着在之前创建的脚本的基础上，右键点击 HTTP请求—->定时器—->Synchronizing Timer。

第二步

设置集合点：

Number of Simulated Users to Group by： 每次释放的线程数量。如果设置为0，等同于线程组中设置的线程数量。

Timeout in milliseconds： 如果设置为0，Timer将会等待线程数达到了"Number of Simultaneous Users to Group"中设置的值才释放。如果大于0，那么超过Timeout in milliseconds中设置的最大等待时间(毫秒为单位)后还没达到"Number of Simultaneous Users to Group"中设置的值，Timer将不再等待，释放已到达的线程。

注意：

如果设置Timeout in milliseconds为0，且线程数量无法达到"Number of Simultaneous Users to Group by"中设置的值，那么Test将无限等待，除非手动终止。
Synchronizing timer 仅作用于同一个JVM中的线程,所以，如果使用并发测试，确保"Number of Simultaneous Users to Group by"中设置的值不大于它所在线程组包含的用户数。

1天通过3家技术面试是什么样的一种体验

Tue, 17 Jun 2025 17:29:15 +0800

今天有个同学很兴奋的告诉我，她今天一天就通过了3家公司的技术面试。

我得知这个消息也非常开心，顺便就问了一下她的心得体会，如何才能做到一天之内三战三捷的。

首先应该是学习。

互联网行业或者是it企业知识是不断更新迭代的，之前的经验在很多时候很可能不是优势，而是会局限你的认知。就拿我自己举例子，当年在angular js/vue js/react js刚诞生的时候，我还是拘泥于之前的jquery思维，认为开发玩转jquery基本上就可以搞定一切了，但如今jquery基本上是属于上古的技术了，vue js和react js基本上在前端领域处于统治地位。持续的以空杯心态进行学习很重要，之前的经验也许有帮助，但不能过于拘泥，技术革命总是很残酷，新事物的崛起总会让一些守旧的人付出代价。花点时间去学习一些你难以理解的东西，这种投资其实非常值得。

但是学习和尝试意味着要花费大量的时间，如何高效持续的进行学习呢？这位同学的做法我觉得是很可取的，那就是把学到的东西运用在项目里。

举个例子，假如你测试的项目/产品有微信端的小程序，那么你可以学习接口的自动化测试，因为微信小程序会调用后端接口，加上一定的前端逻辑之后将页面渲染出来展示给用户。这种前后端分离的模式是现在的主流开发方式，分离之后前端管交互和展示，后端管逻辑和数据。数据和逻辑相对于用户看到的复杂页面来说本身就屏蔽了很多无用的信息，自动化验证和比对的难度也会降低不少，给自动化带来了不错的落地机会，很适合在项目中进行尝试。这种尝试的过程其实就是学习的过程，不要怕最终的结果达不到预期，这种追求的过程其实才是最重要的。

然后就是给团队安全感。

一般情况下，那些被认可的测试同学往往会给团队很强的安全感，这种安全感体现在方方面面，比如线上问题的定位，发布流程的保障，文档的整理，质量问题的总结等。

这位同学很显然是不经意间做到了这一点。她说自己主动一点，做一些看似鸡肋的工作，比如业务文档整理，自己复盘，同样的问题不出现两次；最后做好业务支撑和质量把控，坚持做下去，团队会对你产生信赖甚至是依赖，也会给你带来不错的话语权，有了话语权你才能去推动一些看上去费力不讨好但在工程技术层面很重要的事情，比如持续集成，单元测试等等。

这位同学的经历其实很典型，是属于厚积薄发的例子。每天都进步一点点，日积月累以后竞争力就会比较明显了。

最终她拿3份offer都顺利拿到，不过她最心仪的一家给的薪资涨幅是最少的，但也达到了18k。其实也有给到20k的，不过考虑到发展，还是去了18k的那一家。

最后还是真诚的祝贺这位同学，当学习成了一种习惯，后面的事情就会水到渠成了。

大家一起继续加油吧。

原始封面

2020年了，终于可以让siri帮我们做自动化测试了

Tue, 17 Jun 2025 17:29:15 +0800

2020年是一个魔幻的年份，那么在这一年里，我们不妨玩的更科幻一点。

在下面这个视频里，我们看看怎么样使用siri帮我们做自动化测试吧。

原理分析

原理其实很简单。首先用语音唤醒siri，调用ios的快捷指令，自动给在公司的小伙伴打电话，让他们配合表演，做一阵各种操作，把测试结果返回。

当然，这是开玩笑的。

真正的原理如下图所示

其实就是用语音唤醒siri之后调用ios的快捷操作app，通过ssh到远程服务器的方式，调用远程服务器上的测试脚本，运行用例，并将结果返回。

用到的设备

一台ios机器，iphone和ipad都可以，升级到最新版本
一台云服务器，能ssh访问

测试用例

因为偷懒的关系，我就没有写特别复杂的用例了，这里我就用python简单测试了一下重定向科技的所有课程页面，属于简单的界面UI测试范畴。

不过这里没有用到selenium，而是直接发送1个get请求拿到页面的html，然后从html标签中分离出我想要的关键信息做断言。

先写自然语言的用例

发GET请求到http://www.itest.info/courses
拿到html后用css选择器.servive-block-in > h4拿到所有课程的名称
课程名称里包含全栈测试开发班这个课程，这里用包含断言，提升了用例的鲁棒性，也就是说跑多次不容易报错

再用python去实现一遍


import requests, unittest
from bs4 import BeautifulSoup

url = 'http://www.itest.info/courses'
html = requests.get(url).text
soup = BeautifulSoup(html, 'html.parser')

titles = [i.text for i in soup.select('.servive-block-in > h4')]
course_name = '全栈测试开发班'
assert course_name in titles, '{}不在课程列表中'.format(course_name)
print(titles)
print('All good')

这里用到了2个第三方库

requests：简化http的各种操作
BeautifulSoup4: html parser，方便我们从html标签中分离出各种有效信息

用例的整体思路借鉴了多年前google提出的测试降级思路，也就是如果页面上的一些元素可能是干扰项，那么就需要在用例中去掉这些干扰，实际上这个脚本其实就是一个简单的爬虫，只是加了断言而已。

确保可以远程运行

将脚本放到云服务器上，运行

python itest.info.py

结果应该如下

['全栈测试开发班', '性能测试班', '接口自动化测试开发--Python班', 'Selenium自动化测试--Python班']
All good

配置快捷指令

一步一步按图来配置就好了。

这里我配置了

通过ssh运行脚本，在这里选择ssh到了远程服务器，并执行了shell脚本
播放声音，这个纯属为了好玩
最后显示shell脚本结果，把运行的结果返回回来

配置好快捷指令之后就可以用siri去运行这个指令了。

最后

用siri去执行自动化测试脚本，听上去感觉脑洞很大，但只要了解了原理，就会发现其实并不算困难。

整个过程看上去很简单，但其实包含了一些值得分享的思路。

能在命令行里跑的都在命令行里跑
能在云服务器跑的都在云服务器上跑
工作中其实有很多地方都可以用到自动化，主要看脑洞够不够大

通过siri + 快捷操作的方式，你还可以实现

通过siri去部署
通过siri去运行爬虫
通过siri去执行jenkins任务，ssh到一台跳板机，然后通过curl运行jenkins api
其他更多….

有兴趣的同学不妨亲自动手试一下，跑通了流程以后也许可以在面试的时候表演一下，比如假装收到告警短信，然后低调的语音唤醒siri，说跑一下现网的监控测试，然后就优雅的等待测试结果或翻车，总之，人生如戏，全靠演技。

2021年春节国外程序员在忙什么？

Tue, 17 Jun 2025 17:29:15 +0800

2021年的春节就这样平平淡淡的过去了。

经历了2020年春节的惊心动魄和焦虑挣扎，现在才发现平淡其实才是幸福的所在。

因为平时喜欢逛github，喜欢在trending里翻一些最近热门的开源项目，从而洞察一些基本的技术走向和猎奇一些有意思的项目工具，经过多年的观察，我发现github的python语言趋势相当接地气，我们可以从中看到国外的主流技术圈最近在关注些什么，思考些什么以及忙些什么。

2021年2月的python趋势的现实意义格外的明显，我们可以看到国外的程序员大概在关注下面一些技术以及热点。

数据可视化

apache/superset这个项目热度排在python榜单的首位，该项目主要做的是数据可视化，支持多种数据库和各种图形图表，是数据分析以及展示的一大利器。
streamlit/streamlit也是数据可视化工具，可以用python代码来直接实现基于数据展示的app，实用性也非常的高。
fishtown-analytics/dbt应该也是数据可视化工具，不过具体怎么使用我也不是很清楚。

数字货币

freqtrade / freqtrade, CoinAlpha / hummingbot, CryptoSignal / Crypto-Signal, bitcoinbook / bitcoinbook, sammchardy/python-binance, yasinkuyu/binance-trader ,pyca/cryptography等项目上榜。

这些项目涉及数字货币的自动交易，数字货币教程等方面，榜单的24个项目中数字货币相关的项目占到了7个，占比为30%左右，呈屠榜态势，这个2月数字货币炙手可热。

金融市场

2021年的金融市场有酒有故事，魔幻而浪漫。

榜单中mrjbq7 / ta-lib, ranaroussi / yfinance为金融相关项目，稍微看了一下这两个项目的api，基本的作用就是看盘和分析，春节期间看来不少老外在忙着炒股。

机器学习以及人工智能

机器学习类的项目一直在python热榜中占比很高，这次 PaddlePaddle / PaddleOCR, microsoft / DeepSpeed, eriklindernoren / ML-From-Scratch上榜，加上之前的榜单中一直霸榜的tensorflow等项目，机器学习这些年热度一直颇高，值得大家学习。

新冠病毒

owid/covid-19-data这个项目每日实时更新新冠的一些数据，比如确诊数等，结合上面的数据可视化工具应该可以做出各种图表，帮助我们了解目前疫情在全球的蔓延情况。

其他

其他还有诸如

python/mypy这是python的静态类型检查工具，可以简单的理解为typescript之于javascript，为python做静态类型分析，从而减少运行时的一些低级错误
qutebrowser/qutebrowser一个有意思的浏览器，支持vim键位，极客的选择，不过不知道可用性如何，毕竟是使用python开发的，运行效率可能是瓶颈

总结

从python热榜中我们可以得到下面的一些关键字

大数据与机器学习
数字货币
股票市场
新冠疫情

这些是春节期间国外程序员关注的点，其中大数据与机器学习是长期趋势，股票市场只是近期热度飙升，数字货币浮浮沉沉，不定期屠榜。

完整榜单

1 " apache / superset"
2 " freqtrade / freqtrade"
3 " PaddlePaddle / PaddleOCR"
4 " CoinAlpha / hummingbot"
5 " microsoft / DeepSpeed"
6 " CryptoSignal / Crypto-Signal"
7 " sammchardy / python-binance"
8 " owid / covid-19-data"
9 " bitcoinbook / bitcoinbook"
10 " mrjbq7 / ta-lib"
11 " qutebrowser / qutebrowser"
12 " ranaroussi / yfinance"
13 " yasinkuyu / binance-trader"
14 " streamlit / streamlit"
15 " netbox-community / netbox"
16 " microsoft / cascadia-code"
17 " fishtown-analytics / dbt"
18 " kangvcar / InfoSpider"
19 " explosion / spaCy"
20 " python / mypy"
21 " eriklindernoren / ML-From-Scratch"
22 " psf / black"
23 " FengQuanLi / ResnetGPT" //中文项目，剔除
24 " pyca / cryptography"
25 " dask / dask"

原始封面

2021年的第一个flag--cypress实战教程

Tue, 17 Jun 2025 17:29:15 +0800

cypress的目的是为前端开发同学降低日常工作中重复的end to end测试工作量，提高测试效率，尽管是面向开发，但测试同学花时间去学习还是非常值得的。

会测试的开发其实是受欢迎的，会开发的测试竞争力也是有目共睹的。

前几天听到一个理论，要想达到高收入，那么你可能需要在某一个领域技能达到90或100分，显然这是很难的。

但是你也可以跨界，为自己多开辟一个赛道，你可以在某个领域做到50分，然后另一个领域也是50分，这样合起来也是竞争力比某个领域精通的90分其实也不差，测试学习开发技能的底层逻辑也就这里。

既然对于大多数人来说，炒房资金不足，又不想去股市币圈当韭菜，那么把有限的时间和金钱花在投资自己身上，其实是明智的决定。

随手在搜索引擎上找了一下，发现结构良好的cypress教程还是屈指可数的。

新的一年到来了，不如先立个flag，写一套cypress的实用教程吧。

那我为什么要写教程呢？

写教程也是学习的过程，我需要持续学习来提升自己的竞争力
写教程让人痛苦，不过有痛苦才会有进步，撸铁的同学肯定有类似的体验
我乐于分享，而且坚持了好久，成了习惯
有了文字教程就可以尝试视频教程，剪辑制作高质量的视频教程也是我2021年想提高的点

既然是实用教程，那么一定要从实际项目开始，好在cypress非常贴心的提供了cypress realworld项目，尽管这个项目没啥现实生活中的实际实用意义，不过有前端，有后台，有单元测试用例，接口测试用例以及ui测试用例，五脏俱全，工整优雅，来源于学习的目的，但实际上对我们的测试思路还是有很好的指导效果的。所以cypress教程不如换个思路来做，直接看别人的项目是怎么做自动化测试的，用例怎么选取的，断言如何写的，项目目录结构是怎么样的，从实战中去补充基础知识，这样效果也许会更好一点，或者是更功利一点。

整体思路

分析cypress realworld项目，地址：https://github.com/cypress-io/cypress-realworld-app，从项目中学会

typescript的简单语法，因为项目是typescript写的，会一点简单的语法方便我们进行源码阅读
体验cypress realworld项目，梳理出主要功能，这是熟悉需求
梳理后端接口和数据结构，这一步是了解后台逻辑实现
了解express,lowdb的简单使用，这一步的目的是为了让我们能看懂项目的后台代码
了解react,xstate的简单使用，为了看懂前端代码，这两个框架的时间投入还是值得的
了解cypress功能
了解前后端分离app的工作模式
单元测试怎么写?看一下实际项目中的单元测试实现
接口用例怎么写？看一下高水平的开发者的接口测试思路
ui测试用例怎么写？这里很难一言以蔽之
database seeding是什么？为什么会降低ui测试的难度？
cypress怎么做ci/cd的？了解ci/cd的工作原理与工作流程

大纲草稿

ts语法简介，主要参考微软官方文档:https://www.typescriptlang.org/docs/handbook/intro.html
cypress realdworld项目部署(也可以不用部署)
cypress realworld项目初体验，输出主要功能文档
cypress的主要功能，参考https://docs.cypress.io/guides/core-concepts/introduction-to-cypress.html#Cypress-Can-Be-Simple-Sometimes
- 重试机制
- 元素的交互
- 分支测试
cypress relaworld的后台接口分析
如何使用express+lowdb实现后台接口
- 数据库设计
- 鉴权
- 路由及持久化实现
分析cypress relaworld的单元测试实现
分析cypress relaworld的接口测试实现
如何使用react+xstate实现前端功能
- react简介以及页面的渲染
- 路由实现
- 状态机实现
- 与后台的交互
分析ui测试用例
- 如何选取用例
- 断言怎么写
- 什么是db seeding，有什么好处
- 怎么调试
- 怎么截图和录视频
- 怎么设置环境变量
- 如何使用test runner去命令行跑指定用例
- 怎么做多浏览器兼容性测试
- 怎么做ci/cd

随便列了一下，发现内容还是相当丰富的，如果一周出一篇的话，基本上半年大半年就过去了。

2021年最适合测试同学学习的技术

Tue, 17 Jun 2025 17:29:15 +0800

2021年已经悄无声息的快过去1个月了，大家已经开始立年度flag了吗？如果没有的话先不急，等我们盘点完2021年最值得测试同学学习和了解的技术之后，也许大家就有立flag的冲动了。

在这里我推荐的技术都是遵循性价比高，也就是投入时间相对较少而产出相对较高这个原则来的，因为我们时间有限，相对来说容易掌握，变动性小，投入时间相对少的技术是大家可以去涉猎的。

语言类

测试同学掌握一门编程语言应该是以后的大趋势所在了，会一门语言意味着你有机会将一些需要花费大量人工做的事情用自动化的方式去处理，这会提高效率，简而言之就是提升了生产力，一个人可以干多个人的活，相对来说内卷的趋势也不会特别明显。前几天看了一本名为《闪电式扩张》的书，里面也提到了自动化一切是让公司在发展时候尽量不受到人力规模因素钳制的重要活动。

语言分为脚本类语言和编译型语言，理想的情况下，两种都会是最好，没有时间的话可以只会脚本类语言。

脚本类语言里推荐2门语言。

python。没有时间精力有限就学python，除了做前端，python现在基本上是十项全能了，前些天在语言排行版上，python已经超过了老将java，并且有可能以后一直压java一筹。语言这个东西很有意思，用的人越多需求量就越大，找到合适工作和岗位的机会就越大，因此学习python对我们的工作和求职都是一定益处的。
JavaScript。有余力的同学可以学一下js，js在前端领域还是强势的选择，不过应用范围比python确实是小很多，但在测试上，我们可以用js调用selenium，appium，cypress，k6,postman等主流工具，日常使用还是绰绰有余的。

编译型的语言推荐2门。

java。老将java市场保有量还是很大的，而已在一些中小型公司仍然是担当主力，市场长期需求相对有保障。而且java基本上也是啥事都可以做，应用范围没有问题，java语法也相对稳定，跨平台和生态都很完善，看重既得利益的话学习java是完全没有问题的。
go。go跟java比可能更着眼于未来一些。相对java来说，go更加现代化，语法也更简单，在一些传统java占优势的领域，比如中间件开发上，go的势头非常强劲，go入门简单精通相对难一些，这个特点很适合一些寻找工具开发语言的测试同学，毕竟很多时候自动化工作只需要简单的调用一些现有库，把流程串起来就好了。

最后的总结就是：没有时间只学python就好了，时间很多可以再学一下go。

测试技术类

我把测试技术狭义的分为工具使用和工具开发。

用现成的工具去解决眼下的问题，对代码的要求相对较低；工具开发其实就是开发了，只是开发的产出物是测试工具而已。

这里我们只讨论前者，我们看一下在各种测试场景或者专项测试上都有哪些工具是值得我们掌握的。

ui自动化测试

web端的自动化测试首推还是selenium，毕竟市场保有量大，需求较为强烈。cypress是一个不错的学习对象，有时间也是强烈推荐学习的。
app自动化目前还是appium的应用相对广泛一些，推荐重点关注。

接口自动化测试

postman。对于http+json的简单接口，postman+newman的组合基本上是可以搞定大部分需求的，强烈推荐，不过要想用的好还是得会一点点的js。我记得我在b站有一套postman的视频，讲的比较清楚了，大家可以去B站搜索测试圈TC去学习一下。
自己写代码去实现。自己写代码实现会更加灵活一些，另外一些rpc或者是私有协议的接口我们也可以比较方便的进行测试。这里需要注意的是断言和数据准备相对比较重要，大家可以去github上搜索一个叫做cypress realworld的项目，看看他们是怎么做接口自动化的，当然他们用的是cypress做接口自动化，工具其实不算特别重要，思路和用例组织才是关键。

单元测试

各种语言内建或者标准的单元测试库。python有unittest，java有相对标准的junit，go有testing库，这些框架的优势是简单易用，用来做单元测试基本上问题不大，但缺点是过于简单，有时候需要深度定制；
各种语言的高级测试库。python有pytest，java有testNG等，这些框架相对功能全面很多，可以满足大家更高级的需求。

服务端性能测试

k6。k6是一个比较新的性能测试工具，支持http和grpc，对开发人员非常友好，而且官方文档讲了很多测试理念的东西，讲招式的同时又传授内功，这点跟cypress很像，推荐一下；
wrk。只支持http协议，但是性能强大使用简单，居家常备的性能测试利器；
jmeter。干啥都可以，但都有点麻烦的老牌性能测试工具，有ui，入门相对简单

移动端性能测试工具

perfdog。支持ios和android的性能指标采集，非常适合小白，强力推荐的工具；
系统自带性能测试套件。比如ios的instrument，在专业场景上有巨大的优势，比如看memory leak之类，这也还是需要掌握的；

pentest工具

这里我也不是很了解，等以后学会了再分享给大家。

通用技术类

通用技术可以让你了解你的被测系统是如何工作的，可能在哪里会存在潜在问题，也是打通跟开发交流次元壁的重要方式。

传统的通用技术这里就不列举了，不过从目前来看，机器学习技术可能是需要大家重点关注的，因为长期来看，机器学习的应用范围会越来越广，相应的测试活动应该也会有更多的市场需求。

总结

总之技术对于测试同学来说只是日常工作的一部分，在很多时候我们的工作重心可能还是沟通，协调，深刻理解好需求，做好质量管理和线上问题跟踪，这些可能会占据我们大部分的时间和精力。不过从内在的核心竞争力来看，技术驱动自身价值增长应该是不变的趋势。

前几天看到个视频，讲股票投资的，里面有一些观点其实比较主流。

当外卖送餐员可能不是一个好主意，因为在这个岗位上你无法得到提升。同样的当点来点去的测试员可能也不是好主意，没有技术壁垒和核心竞争力，长期来看成长是不足的；
散户投资股票长期来看是亏，投资自己收获能力提升才是普通人应该去关注的事情；

以上观点感触很深，所以跟大家分享一下，我们还学的动，还有时间，一起加油吧。

顺便立个flag，今年希望可以把机器学习给整明白，然后与大家分享。

原始封面

2021年最值得测试同学使用的python库

Tue, 17 Jun 2025 17:29:15 +0800

2021年不期而至了，我们不妨盘点一下2021年最值得测试同学使用的python库/工具吧。

Validation

jsonschema: An(other) implementation of JSON Schema for Python

jsonschema可以用来进行json数据的校验。试想一下这样的场景，我们需要验证api返回的json字符串的正确性，但如果一个字段一个字段去校验效率自然是不高的，这时候jasonsschema就可以大展身手了。

>>> from jsonschema import validate

>>> # A sample schema, like what we'd get from json.load()
>>> schema = {
... "type" : "object",
... "properties" : {
... "price" : {"type" : "number"},
... "name" : {"type" : "string"},
... },
... }

>>> # If no exception is raised by validate(), the instance is valid.
>>> validate(instance={"name" : "Eggs", "price" : 34.99}, schema=schema)

>>> validate(
... instance={"name" : "Eggs", "price" : "Invalid"}, schema=schema,
... ) # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
 ...
ValidationError: 'Invalid' is not of type 'number'

我们可以自定义schema，如果api返回的结果满足schema定义的规则的话，那么用例就通过，否则失败，用例的编写效率和准确性都可以得到提升。

项目地址:https://github.com/Julian/jsonschema

算法

algorithms:Minimal examples of data structures and algorithms in Python。

库如其名，用python实现了各种常见算法，实现优雅，例子相对简单，适合学习。项目地址：https://github.com/keon/algorithms

命令行工具

howdoi:instant coding answers via the command line

写代码的时候经常会不知道某个功能怎么实现或者代码报错需要去搜索一下解决方案，但每次打开浏览器搜索的话还是比较麻烦的，这时候howdoi就有用武之地了。

2021年最值得测试同学使用的四种编程语言

Tue, 17 Jun 2025 17:29:15 +0800

2021年马上就要到了，那么新的一年哪些编程语言值得测试同学学习和使用呢？我们不妨简单来看一下。

python

python目前基本上成为了一门通用语言，有点像是英语在世界语言中的地位。

我们可以这么认为，在工作中不使用python其实没什么大问题，不过如果能熟练使用python，那么工作效率和效果将有极大的提升。

python因为语法简单执行效率尚可，扩展性强等优势在一些传统领域和新兴领域都备受推崇，使用python我们可以

做web开发
做自动化构建
玩一下计算机视觉相关的东西
做一些科学计算
数据统计与可视化
深度学习
自动化测试及网络爬虫
开发各种cli工具等
游戏开发
文本处理

所以如果大家只有时间掌握一门脚本语言的话，python是非常好的选择。

javascript

因为nodejs的出现，js在应用场景上有了巨大的扩充，之前只能在浏览器上做一些前端效果的js如今基本上成为了一门非常方便的脚本语言，我们可以使用js进行

web开发，包含前后端
移动端开发，比如使用rn
cli工具开发
自动化构建
游戏开发
文本处理
自动化测试
GUI开发，比如vscode就是js开发的

如果大家从事的工作跟前端有很多交集，那么js是一门值得掌握的脚本语言。

java

老当益壮的java在编译性语言里目前还是有着不错的表现的。java目前在一些领域还是有着比较大的保有量

web后端开发
通用后台开发，比如java有一些不错的微服务框架
分布式编程
GUI开发
中间件开发，比如es, zk
自动化测试，比如selenium

作为一门优秀的编译型语言，java基本可以满足大多数测试同学的需求。

go

golang凭借着简单易学的语言元素以及不错的开发效率和执行效率，近几年变得越发流行。

如果大家有时间学习一门编译型语言，我可能会更推荐go而不是java。go可以做这些事情

cli工具开发，docker的cli就是go写的
各种中间件，比如promethus就是go实现的
分布式系统
web后台开发，通用后台开发
性能测试以及接口测试
gui开发
游戏开发

go的学习曲线在编译型语言里应该是比较平滑的，很适合测试同学写一些小工具和后台。

总结

总之测试同学可能学习两种语言就可以了，一种是编译型，另一种是非编译型的脚本语言。

时间充足都学，时间不够，只学脚本语言，而且无脑选择python就好了。

原始封面

curl太难用？试试httpie吧

Tue, 17 Jun 2025 17:29:15 +0800

curl是功能非常强大的命令行http客户端，也许是正是因为强大吧，所以很多同学记不太住curl的一些常用参数，再加上curl的命令行参数形式又比较老派，所以日常用起来还是有一点点略显啰嗦的。

既然curl太难用？那我们就试试httpie吧。

项目地址：https://github.com/jakubroztocil/httpie。

一句话介绍，我就不翻译了。

As easy as HTTPie /aitch-tee-tee-pie/ 🥧 Modern command line HTTP client – user-friendly curl alternative with intuitive UI, JSON support, syntax highlighting, wget-like downloads, extensions, etc.

httpie的特点

用户友好
非反直觉的ui
支持JSON
支持语法高亮
支持文件下载
支持插件

一图以蔽之

安装

Mac

$ brew install httpie
# or
$ port install httpie

Linux

# Debian, Ubuntu, etc.
$ apt-get install httpie

# Fedora
$ dnf install httpie

# CentOS, RHEL, ...
$ yum install httpie

# Arch Linux
$ pacman -S httpie

Windows*

puppeteer生态一览

Tue, 17 Jun 2025 17:29:15 +0800

puppeteer是chrome官方出品的无界面浏览器，我们一般称为无头浏览器。

这种浏览器具有普通版浏览器的完备功能，并且可以运行在无界面的服务端，比如远程的linux服务器上，是做ui自动化测试的一个不错的选择。

我们今天就来看一下puppeteer的生态，看看除了自动化测试这个工具还能做什么吧。

Puppetron

https://github.com/cheeaun/puppetron，这个项目的功能非常简单，就是使用puppeteer来渲染页面并且进行截图或者是将页面保存成pdf文件。

你可以通过api调用来完成上述的3个功能，渲染/截图以及保存pdf都支持宽高设置，所以你可以很容易的实现模拟不同大小屏幕的功能。

比如你可以通过设置不同的宽高来得到某个网站在小屏手机/大屏手机/平板以及电脑上的屏幕截图。

pupperender

https://github.com/LasaleFamine/pupperender，pupperender是一个express中间件，它的功能是如果探测到这次页面的访问是来自搜索引擎的机器人或者是爬虫，那么就自动使用puppeteer来渲染页面，返回完整的html。

该工具就解决了一些前后端分离的站点对搜索引擎不友好的问题，因为如果是纯js实现的前端页面，那么搜索机器人爬到的页面仅仅包含一些基本的html，页面的具体内容是没办法正确渲染出来并返回的。

该库的使用也非常的简单，几行代码就可以搞定了。

const express = require('express');
const pupperender = require('pupperender');

const app = express();

app.use(pupperender.makeMiddleware({}));

app.use(express.static('files'));
app.listen(8080);

有困惑的同学可以搜索PWA进行更深入的学习。

headless-chrome-crawler

https://github.com/yujiosaka/headless-chrome-crawler，是使用puppeteer实现的爬虫。

它的一些功能还是非常有特色的，比如

支持分布式爬取
实现了深度优先和广度优先算法
支持csv和json line格式导出
插件式的结果存储，比如支持redis
自动插入jquery，可以使用jquery语法进行结果处理
支持截图作为爬取证据
支持模拟不同的设备

简单看一个例子

const HCCrawler = require('headless-chrome-crawler');

(async () => {
 const crawler = await HCCrawler.launch({
 // Function to be evaluated in browsers
 evaluatePage: (() => ({
 title: $('title').text(),
 })),
 // Function to be called with evaluated results from browsers
 onSuccess: (result => {
 console.log(result);
 }),
 });
 // Queue a request
 await crawler.queue('https://example.com/');
 // Queue multiple requests
 await crawler.queue(['https://example.net/', 'https://example.org/']);
 // Queue a request with custom options
 await crawler.queue({
 url: 'https://example.com/',
 // Emulate a tablet device
 device: 'Nexus 7',
 // Enable screenshot by passing options
 screenshot: {
 path: './tmp/example-com.png'
 },
 });
 await crawler.onIdle(); // Resolved when no queue is left
 await crawler.close(); // Close the crawler
})();

上面的例子就演示了使用jquery语法title: $('title').text() 获取页面信息以及模拟特定的设备Nexus 7进行爬取以及截图的功能。

Selenium踩坑指北

Tue, 17 Jun 2025 17:29:15 +0800

最近在翻selenium的官方文档，秃然发现了一份官方的selenium踩坑指南，不敢独享，拿出来给大家分享一下。

众所周知，我们应该把合适的工具用在合适的场景，这跟杀鸡的时候不需要用到宰牛刀是一样的道理。

selenium比较好的使用场景是验收测试/回归测试/TDD/BDD，一些同学喜欢把selenium用到某些selenium难以承受的场景，这种方式官方是不推荐的。

下面这些是官方给出的各种神坑，有兴趣的同学可以亲自踩一下。

验证码

一般来说我们不需要用selenium去处理各种验证码，有兴趣的同学可以逆向思维，亲自试试。

那么遇到验证码怎么办？

测试环境就关掉验证码
留个后门，比如万能验证码

下载文件

尽管我们可以使用selenium去点击下载按钮，从而达到下载文件的目的，但是这样做其实并不好。首先处理起来可能比较麻烦，另外关于下载时间下载速度以及下载完整性的验证我们是不太好做的。

一般来说，建议用selenium拿到下载链接，然后使用libcurl之类的库去直接处理下载比较好。用python的同学可以用requests库去处理下载了。

HTTP 请求的响应码

这一part官方苦口婆心的解释了很多，大意是selenium是站在用户角度去自动化测试，对于终端用户来说，他们并不直接关注请求的返回码，他们关注的是能不能看到404的错误页面之类的可以直接感受到信息。

下面是非官方的建议，嗯，也就是我的建议

如果你真的关注响应的状态码，那么别在ui自动化层去做，试着去在非ui层，比如接口层做
放弃在ui自动化用例中断言状态码的努力，有舍才有得嘛

第三方登陆

使用selenium去自动化第三方登陆原则上是不推荐的。因为

增加了用例的复杂度和运行时间，用例容易跑失败
第三方登录是不稳定的，这会让你的登录变得不稳定

在国外一般第三方登录的提供方会提供对应的API，我们可以把登录API集成到用例里，这些API相当稳定，比用selenium去自动化登录过程要好。

国内可以通过类似的思路去做，比如微信登录就有自己的API，这种实现比较硬核，并且跟ui自动化结合起来也有一定难度，有需求的同学可以尝试一下。

用例依赖

这个问题甚合我意，终于有官方文档背书了。

selenium team说了，用例直接不要有依赖，要可以用任意顺序运行，原因我之前的文章里有大量说明，大家可以去翻一下。

性能测试

简而言之，selenium不适合做性能测试，原因我就不详细说了，总之不合适的话咱就不要强求，有情人总会终成眷属。

如果需要做性能测试，可以看看jmeter，官方推荐，值得信赖。

链接爬虫

用selenium去遍历一些链接从而达到爬虫的效果官方是不推荐的，理由是慢，有很多更好的替代方案。

这里我持有保留意见，对于一些反爬虫很厉害的网站，用selenium做爬虫其实是不错的选择，具体原因就不说明了，大家尝试之后也许就会理解。

对于学习selenium的同学来说，用selenium做爬虫其实是非常好的练习方式，尽管爬内容的效率不高，但咱们的目的是多写代码，多练习selenium的api，所以其实我是推荐大家把selenium当练习性的爬虫来用的。

好了，上面这些官方坑是大家可能会经常遇到的，你在使用selenium还遇到过哪些坑呢？欢迎评论留言。

原始封面

安利一下pytest的mark用法

Tue, 17 Jun 2025 17:29:15 +0800

昨天有同事分享了pytest的相关内容，忽然想起pytest在运行用例时有非常大的灵活性，很适合跟jenkins任务结合起来实现一些动态用例运行的效果。

我们以下面这个非常简单的测试用例为例，说明一下如何使用pytest实现一些动态的测试策略

# runner_example.py
import pytest

@pytest.mark.p1
def test_1():
 assert 1 == 1

@pytest.mark.p2
def test_2():
 assert 1 in [1, 2, 3]

@pytest.mark.p3
def test_3():
 assert 3 / 2 == 1

@pytest.mark.p0
def test_4():
 assert 'abc'[::-1] == 'cba'

上面例子里，我们使用@pytest.mark装饰器定义了4种类型的用例，分别是p0/p1/p2/p3。按惯例，p0的用例是优先级最高的用例，p3优先级最低。

场景1: 只运行p0的测试用例

这个非常简单，在命令行中输入

pytest runner_example.py -m p0

这里runner_example.py是包含测试用例的名字，默认情况下pytest会认为所有名称以test_开头的函数都是测试用例。

运行结果

================================================================ test session starts =================================================================
platform darwin -- Python 2.7.15, pytest-4.6.3, py-1.8.0, pluggy-0.12.0
rootdir: /Users/yichun.han/code/testclass.net/src/pytest
collected 4 items / 3 deselected / 1 selected

runner_example.py . [100%]

符合预期。

场景2: 只运行p0和p1的用例

可以用or来实现。

pytest runner_example.py -m "p0 or p1"

-m参数后面可以接python的表达式，所以用or关键字就可以实现多选的效果了。

运行结果

================================================================ test session starts =================================================================
platform darwin -- Python 2.7.15, pytest-4.6.3, py-1.8.0, pluggy-0.12.0
rootdir: /Users/yichun.han/code/testclass.net/src/pytest
collected 4 items / 2 deselected / 2 selected

runner_example.py .. [100%]

================================================================== warnings summary ==================================================================

可以看到运行了2个用例。

保持危机感，等到背锅闪人就晚了

Tue, 17 Jun 2025 17:29:15 +0800

我的车油箱很小，经常开两天油就见底了，因此现在养成了经过加油站就顺道加油的习惯。

这跟我们持续提升自己是一个道理，学到的东西就像是油箱里的油，总有用完的时候。

经常自学充电才能持久续航，等到想换工作的时候才发现要学的东西太多，时间不够用，那时候大概就有点晚了吧。

我经常开玩笑说，测试同学的求生欲其实很强。

前几天我坚持半夜发了个hotfix版本，其实就是求生欲强的最好表现，因为如果不去强发，那么某个比较影响用户体验的缺陷会遗留到线上，等到用户投诉过来的时候那就晚了。

不过hotfix终究是亡羊补牢，是剑走偏峰，是七伤拳，杀敌一千自损八百；是葵花宝典，欲练神功，你懂的。

提前保持危机感其实是个不错的方式。

举个例子，现在我们在发布前拜关公拜服务器其实就是有危机感的表现，但如果只是临时抱佛脚，效果始终有限，在发布之前的反复测试和调优可能效果会更好一些。

测试也是一样，等到发现线上问题以后再去临时修修补补始终是

原始封面

比selenium体验更好的ui自动化测试工具: cypress介绍

Tue, 17 Jun 2025 17:29:15 +0800

不小心发现了一个新的ui自动化测试工具:cypress，仔细品了一下之后，发现还是有很多有意思的地方的，我们也许可以从cypress里借鉴很多下一代测试工具的设计思想。

进入cypress的官网(https://www.cypress.io/)，引入眼帘的一句话让人血脉喷张。

The web has evolved. Finally, testing has too.

web已经进化了，最终，测试也会。

确实相较于这些年前端技术井喷式的增长来说，自动化测试技术的发展是相对缓慢的。

selenium一套api基本稳定了好多年，最终越走越抽象，由工具下沉到了协议，再由协议变成了各大浏览器厂商都公认的标准，尽快步子不大，但走的相当坚定。从招式套路演变成了内功心法，由懵懂少年变成了武林盟主，目前基本上母仪天下，催生了一些很有特点的测试工具。

selenium项目对web自动化测试最大的贡献就是统一了标准，曾几何时webdriver刚出道的时候，各大浏览器厂家对webdriver的支持力度是完全不一样的，比如在之前的很多年，官方维护的driver似乎只有google的chrome，微软的IE浏览器一直用的是民间的IE Driver。后来chrome把IE挤到了历史的垃圾堆里，微软的edge浏览器最终推出了官方维护的edge driver，safari的driver也由苹果官方推出，主流浏览器厂商全部支持了webdriver协议，江山一统，天下舍selenium其谁。

不过selenium的体验对于纯测试同学来说还是有一些硬核的，比如

首先必须安装一门语言，比如java/python/nodejs/ruby之类，这个过程如今在windows上面不算特别难，不过十多年前在windows上安装ruby确实不是一件轻松的事情
安装selenium。这时候大家会接触到诸如maven/pip(python -m pip/pip3)/rubygems/npm/yarn之类的概念，对于完全没有经验的同学来说，是有一定的挑战的，当然了，如果你具备基本的学习的自我学习能力，这个过程应该不会特别的难，除非你遇到了复杂的网络问题，那个另说
折腾IDE。很多同学喜欢折腾IDE，比如pycharm/IntelliJ之类的，搞完安装搞破解，搞好破解搞字体，搞到后来又去弄IDE内执行代码，各种一键配置，全套体验完，大好青春年华就白驹过隙了。另外IDE是为了提升开发效率的，代码写的越多效率提升越高，但是新手往往憋大招半天也写不出几行可以一次性运行通过的代码，IDE的优势基本发挥不出来，所以有这个时间去惆怅去彷徨，不如随便找个编辑器老老实实多敲几行代码吧。我基本上从来不去折腾IDE，因为这是可选项，并非必选，而且我智商有限，IDE的强大功能基本用不上，一直老实巴交的用文本编辑器加命令行，够用了
下载浏览器驱动。当年的selenium安装包里包含了firefox的驱动，稳定而高效，所以如果你用firefox做测试，那么安装好selenium就可以愉快的做自动化了。不过后来firefox换成了gecko引擎，并且由官方维护驱动后，下载浏览器驱动就成了必选项了。
写代码。这个相对简单，网上一堆教程。

所以虫师的selenium自动化测试书籍那么受欢迎是有很充分理由的，有他在前面带路，起码更多的人可以尝试着去用上selenium，至于用例能不能坚持写下去另说，但是入门的门槛是相对低了不少的。

上面列举了selenium的硬核操作，不知道大家会不会产生这样一个观点，那就是selenium似乎对手工测试同学不太友好。

这个想法其实在一定程度上是对的。selenium本身的使用对象就是有一定编程能力的测试同学，因为selenium是国外项目，它的诞生是符合国外的一些实际情况的，比如在国外有些地方，测试是懂开发的，同样开发也是做测试的。

所以selenium其实不是硬核，只是对于我们一些国内的测试同学来说，selenium有点曲高和寡了，并不是到手就用的傻瓜式的开源测试工具。另外selenium的一些核心用户其实是做会做自动化测试的开发同学，selenium的这种工具形态对于开发来说，相对是非常友好的。

所以我们可能忽略了一个事情，在自动化测试发展的很长一段时间内，开发其实是自动化测试的主力军，一些测试工具的设计风格偏开发的路子就很容易理解了。

今天介绍的cypress是一个比selenium还亲开发的自动化测试工具。

在官方文档的Testing Your App章节(https://docs.cypress.io/guides/getting-started/testing-your-app.html#Step-1-Start-your-server)，有这样的一段话，原文很长，摘几句重点

The last, and probably most important reason why you want to test against local servers, is the ability to control them. When your application is running in production you can’t control it.

When it’s running in development you can:

take shortcuts
seed data by running executable scripts
expose test environment specific routes
disable security features which make automation difficult
reset state on the server / database

With that said - you still have the option to have it both ways.

Many of our users run the majority of their integration tests against a local development server, but then reserve a smaller set of smoke tests that run only against a deployed production app.

大概意思是自动化测试要想做的爽，那么你就要在开发环境上做，这样你就可以随意控制你的测试环境，并且做一些可以让自动化测试进行的更加顺利的修改。当然了，你也可以在部署好的环境上做自动化测试，不过那样会比较难，可以考虑在这样的环境上执行一部分简单的冒烟测试用例。

编程笔试题(二)插入排序

Tue, 17 Jun 2025 17:29:15 +0800

继续我们的简单排序之旅。

题目

看一下这道编程题。

使用python对list中的元素进行插入排序，并编写unittest单元测试用例来进行验证。

插入排序的过程如下图所示。

盯着上面的图看2分钟，把排序的来龙去脉看清楚。

插入排序的过程是

首先假设队列左边的元素是已经排序过的元素
依次遍历已排序过的元素右边的元素，将该元素与左边已排序的元素做比较，这样左侧已排序的元素个数就会依次增加
重复第二步，直到所有的元素全部排序完成

简单来说，插入排序很像是打扑克的理牌过程。我们手里的牌是已经排序过的，每次新抓一张牌，就将牌插入到手里已排序的牌中的合适位置，保证手里的牌一直是排序过的。

参考答案

import unittest

def insertion_sort(arr):
 length = len(arr)
 i = 1 # 从位置1开始向右遍历，因为我们假设位置0上的元素是已经排序好了的
 while i < length: # 开始抓牌
 j = i # j代表当前已排序的数字的结束位置
 while j > 0: # j < 0时证明已经遍历完了已排序的部分
 if arr[j - 1] > arr[j]:
 arr[j - 1], arr[j] = arr[j], arr[j - 1] # 找到合适的位置插入
 j = j - 1 # 持续遍历已排序的部分

 i = i + 1 # 持续抓牌

class SortTestCase(unittest.TestCase):

 def test_insertion_sort(self):
 test_data_1 = [8, 7, 6, 5, 4, 0, 1]
 test_data_2 = [9, 5, 2, 7]
 copy_of_data_1 = test_data_1[:]
 copy_of_data_2 = test_data_2[:]

 insertion_sort(test_data_1)
 insertion_sort(test_data_2)
 copy_of_data_1.sort()
 copy_of_data_2.sort()

 self.assertEqual(test_data_1, copy_of_data_1)
 self.assertEqual(test_data_2, copy_of_data_2)


if __name__ == '__main__':
 unittest.main()

思考

大家可以思考下面一些问题

插入排序的时间复杂度最好的情况和最坏的情况分别是多少？平均复杂度是多少？

原始封面

编程笔试题(六)单向链表及链表反转

Tue, 17 Jun 2025 17:29:15 +0800

链表是常用的数据结构，简单起见，我们这里只讨论单向链表。

定义

在一些静态语言中，我们可以用数组去存储一组数据，然而数组的大小是固定是，当数组存满了之后，再往里存东西就会有数组越界的错误。

链表可以解决这个问题，我们可以动态的添加和删除链表中的元素，而不需要考虑链表的容量。

链表长下面这个样子。

对于链表来说，链表中的每一个节点我们称之为Node，Node包含1个指针，指向下一个Node节点，链表就是按照一定的顺序把Node给组合起来。其中排在第1位的节点我们称之为链表的头，也就是Head。

在链表中查找数据的过程实际上就是从链表的头开始，然后通过Node的下一个节点指针，一节一节的向后查找。

基本操作

增加一个节点

删除节点

使用python实现

class Node():

 def __init__(self, elm):
 self.data = elm
 self.next = None

 def get_value(self):
 return self.data

class SinglyLinkedList():

 def __init__(self):
 self.head = None
 self.size = 0

 # https://www.programiz.com/python-programming/generator
 def __iter__(self):
 current = self.head
 while current:
 yield current
 current = current.next
 raise StopIteration

 def __contains__(self, elm):
 found = False
 current = self.head

 while current:
 if current.get_value() == elm:
 found = True
 break
 else:
 current = current.next

 return found

 def get_tail(self):
 tail = self.head

 if tail is None:
 return None

 while tail.next:
 tail = tail.next
 return tail

 def get_head(self):
 return self.head

 def is_empty(self):
 return self.size == 0

 def get_size(self):
 return self.size

 def append(self, elm):
 node = Node(elm)
 tail = self.get_tail()
 if tail:
 tail.next = node
 else:
 self.head = node

 self.size = self.size + 1

 return node

 def delete(self, elm):
 if self.head is None:
 return

 current = self.head
 prev = None

 while current:
 if current.get_value() == elm:
 if prev is not None:
 prev.next = current.next
 else:
 self.head = current.next
 self.size = self.size - 1
 return
 else:
 prev = current
 current = current.next



import unittest

class SinglyLinkedListTestCase(unittest.TestCase):

 def test_append(self):
 l = SinglyLinkedList()
 self.assertTrue(l.is_empty())

 # 1
 l.append(1)
 self.assertEqual(l.get_size(), 1)
 self.assertEqual(l.get_head().get_value(), 1)
 self.assertEqual(l.get_tail().get_value(), 1)

 # 1 2
 l.append(2)
 self.assertEqual(l.get_size(), 2)
 self.assertEqual(l.get_head().get_value(), 1)
 self.assertEqual(l.get_tail().get_value(), 2)

 # 1 2 3
 l.append(3)
 self.assertEqual(l.get_size(), 3)
 self.assertEqual(l.get_head().get_value(), 1)
 self.assertEqual(l.get_tail().get_value(), 3)

 def test_in(self):
 l = SinglyLinkedList()
 self.assertTrue(l.is_empty())
 l.append(1)
 l.append(3)
 l.append(5)

 self.assertTrue(1 in l)
 self.assertTrue(3 in l)
 self.assertTrue(5 in l)

 self.assertFalse(2 in l)
 self.assertFalse(4 in l)
 self.assertFalse(6 in l)

 def test_delete(self):
 l = SinglyLinkedList()
 self.assertTrue(l.is_empty())
 l.append(1)
 l.append(3)
 l.append(5)

 # 1 3 5 -> 3 5
 l.delete(1)
 self.assertEqual(l.get_head().get_value(), 3)
 self.assertEqual(l.get_tail().get_value(), 5)
 self.assertEqual(l.get_size(), 2)

 l.delete(4)
 self.assertEqual(l.get_head().get_value(), 3)
 self.assertEqual(l.get_tail().get_value(), 5)
 self.assertEqual(l.get_size(), 2)


 # 3 5 -> 3
 l.delete(5)
 self.assertEqual(l.get_head().get_value(), 3)
 self.assertEqual(l.get_size(), 1)

 # 3 -> None
 l.delete(3)
 self.assertEqual(l.get_size(), 0)
 self.assertTrue(l.get_head() is None)

 l.append(4)
 l.delete(4)
 self.assertEqual(l.get_size(), 0)
 self.assertTrue(l.get_head() is None)


if __name__ == "__main__":
 unittest.main()

问题

针对上面的单向列表，实现列表的反转。

编程笔试题(三)二分查找

Tue, 17 Jun 2025 17:29:15 +0800

题目

看一下这道编程题。

使用python对已排序的list中的元素进行二分查找，如果找到返回True，否则返回False，并编写unittest单元测试用例来进行验证。

二分查找的算法复杂度比直接遍历列表中元素进行查找的复杂度要低，具体是多少大家可以去看一下。

二分查找是这样工作的。

首先找到列表中排在中间的元素，比较目标元素与该元素的大小，如果中间的元素等于目标元素，则返回True，否则返回False
如果目标元素比该元素大，则在中间元素与最后一个元素之间重复步骤1
如果目标元素比该元素小，则在中间元素与第一个元素之间重复步骤1

拿下面一组数组为例。

[1, 2, 3, 4, 5, 6, 7, 8, 9]，假设我们需要查找7。那么我们的步骤是

先找到[1, 2, 3, 4, 5, 6, 7, 8, 9]的中间数字5
7 > 5，于是在[6, 7, 8, 9]中进行二分查找
[6, 7, 8, 9]的中间数字是8
7 < 8 于是在[6, 7]也就是左半边二分查找
[6, 7]的中间元素是7，等于目标元素，于是找到，返回True

可以看到我们只查找了3次就找到了7，如果是遍历的化，我们需要遍历6次，也就是1到6，二分的优势是很明显的。

参考答案


import unittest

def bin_search(arr, target):
 length = len(arr)
 mid = length / 2 # 找到中间元素

 if arr[mid] == target: # 如果该元素等于目标元素
 return True

 if length == 1 and arr[0] != target: # 目标元素不存在
 return False

 if target > arr[mid]: # 如果目标元素大于中间元素
 return bin_search(arr[mid+1:], target) # 在列表的右半边递归进行二分查找
 else: # 小于的情况
 return bin_search(arr[:mid], target) # 在列表的左半边递归进行二分查找


class BinSearchTestCase(unittest.TestCase):

 def test_bin_search(self):
 test_data = [9, 5, 2, 7] # 测试数据
 test_data.sort() # 先排序

 self.assertEqual(bin_search(test_data, 2), True)
 self.assertEqual(bin_search(test_data, 9), True)
 self.assertEqual(bin_search(test_data, 1), False)
 self.assertEqual(bin_search(test_data, 999), False)


if __name__ == '__main__':
 unittest.main()

思考

这里我们使用了递归的方式实现了二分查找，使用递归的好处是逻辑相对简单直观，当然我们也可以使用循环的方式来实现相同的功能。

编程笔试题(四)栈

Tue, 17 Jun 2025 17:29:15 +0800

栈是常用的数据结构。尽管一般的面试里不会让你直接写一个栈的实现，不过跟栈有关的编程题还是有的。

定义

首先看一下栈的定义。栈是一个集合，具有下面的2种基本操作

push: 把元素加入集合，这个过程我们叫做压入
pop: 把最后加入集合的元素从集合中移除，这个过程我们叫做推出

所以栈在移除元素的时候是遵循LIFO(last in, first out)，也就是后进先出的原则的。

下图演示了依次将1, 2, 3, 4, 5, 6加入到栈中并推出的过程。

使用python list来实现栈

我们主要是实现pop和push操作，另外再实现is_empty()方法来判断栈是否为空。

栈为空的意思是栈内没有任何元素了。

我们使用python的list来实现栈，这样比较简单。


class Stack:

 def __init__(self):
 self.data = []

 def __len__(self):
 return len(self.data)

 def push(self, elm):
 self.data.append(elm)

 def pop(self):
 return self.data.pop()

 def is_empty(self):
 return self.__len__() == 0


import unittest

class StackTestCase(unittest.TestCase):

 def test_push_and_pop(self):
 s = Stack()
 s.push(1)
 self.assertEqual(len(s), 1)
 self.assertEqual(s.pop(), 1)
 self.assertEqual(len(s), 0)
 self.assertTrue(s.is_empty())

 s.push(1)
 s.push(2)
 self.assertEqual(len(s), 2)
 self.assertEqual(s.pop(), 2)
 self.assertEqual(s.pop(), 1)


if __name__ == '__main__':
 unittest.main()

可以看出,push()实际就是调用list.append()实现的，而pop()则是调用list.pop()来实现。

编程笔试题(五)队列

Tue, 17 Jun 2025 17:29:15 +0800

队列也是是常用的数据结构。尽管一般的面试里不会让你直接写一个队列的实现，不过了解队列是必须的。

定义

队列在现实生活中非常常见。

比如去一些餐厅吃饭是需要排队的，先来的先吃，这就是一个等待的队列。

队列是先到先出的,FIFO(first in, first out)。队列有下面一些主要操作。

enqueue: 将元素加入队列
dequeue: 将排在最前面的元素推出队列

下面的图演示了这两个过程。

使用python deque来实现队列

python内置了deque(发音是deck)实现。

所谓的deque实际上就是double end queue的意思。

普通的queue只能在尾部推入元素，从头部移除元素，而deque可以从任意方向推入和移除元素。

在命令行里使用pydoc collections.deque可以查看deque类的内置方法。

比较重要的一些方法有

| append(...)
| Add an element to the right side of the deque.
|
| appendleft(...)
| Add an element to the left side of the deque.
| extend(...)
| Extend the right side of the deque with elements from the iterable
|
| extendleft(...)
| Extend the left side of the deque with elements from the iterable
|
| pop(...)
| Remove and return the rightmost element.
|
| popleft(...)
| Remove and return the leftmost element.
|
| remove(...)
| D.remove(value) -- remove first occurrence of value.
|
| reverse(...)
| D.reverse() -- reverse *IN PLACE*
|
| rotate(...)
| Rotate the deque n steps to the right (default n=1). If n is negative, rotates left.

下面是queue的具体实现

编程笔试题(一)冒泡排序

Tue, 17 Jun 2025 17:29:15 +0800

最近了解到很多测试同学在面试做笔试题的时候都会遇到编程题，总的看来测试同学的编程题都不是很困难，主要在考察大家的代码基本功，一般以简单的算法为主。这里就给大家介绍一些最基本的算法，希望对大家的面试有一些帮助。

在阅读文章之前，希望大家有这样的一些知识积累。

能看懂简单的python代码
能写一些简单的python代码并运行起来
知道python的一些简单数据结构，比如list

基本算法里总是离不开排序。所谓的排序就是把一组乱序的数据从大到小或者从小到大的排列出来。

比如一组数字，9，5，2，7，我们按照生序排列的结果就是2,5,7,9。

题目

首先看这道编程题。

使用python对list中的元素进行冒泡排序，并编写unittest单元测试用例来进行验证。

排序算法里最简单的就是冒泡排序。冒牌排序的过程用下面这张图来解释是最合适不过了。

![http://img.testclass.net/Bubble-sort-example-300px.gif]

盯着上面的图看2分钟，把排序的来龙去脉看清楚。

从上面的图里我们可以知道

首先比较每个相邻的元素，把大的元素换到右边，这样每次比较完一行就可以把最大的数字移动到最右边，这就是所谓的冒泡了
重复上面的过程，把每次找到的最大的元素换到当前比较队列的最右

这样一来当所有的循环完成之后排序就自然完成了。

下面就是代码实现了。实现代码的时候我们需要先想明白代码运行的次数。

我们可以把冒泡排序分成2个小的任务,假设有n个数字需要排序

A: 找到当前未排序的数字中最大的数字，将其移动到未排序数字的最右边，具体做法遍历当前未排序的数字，将该数字与右边的数字进行比较
B: 循环n次A

对于B来说，循环次数很明确了，就是n次。对于A来说，第1次循环的最后应该是比较第n-1与第n个元素，如果有比较就进行移动，第2次循环是比较第n-2个元素和第n-1个元素，因为第n个元素是当前最大的已经排序的元素了，所以没有必要与第n个元素进行比较。依次类推可知A其实就是从n-1开始，到1结束。

这里其实有2个变量控制循环逻辑

未排序元素的结束位置，A使用
已经找到的最大元素的个数, B使用

参考答案

import unittest

def bubble_sort(arr):
 length = len(arr)
 for i in range(length): # i 就是当前已经找到的最大元素个数，从0开始，表示找到了0到n个
 for j in range(length - i - 1): # 任务A的具体实现，每次循环的结束点都是比较当前未排序元素的倒数第2个和最后1个
 if arr[j] > arr[j + 1]:
 arr[j], arr[j+1] = arr[j+1], arr[j] # python中交换变量值的语法糖，面试里这样写大概能加分把
 # tmp = arr[j] 这样交换也可以，不过没有上面写法显得老练
 # arr[j] = arr[j+1]
 # arr[j+1] = tmp


class SortTestCase(unittest.TestCase):

 def test_bubble_sort(self):
 test_data_1 = [8, 7, 6, 5, 4, 0, 1]
 test_data_2 = [9, 5, 2, 7]
 copy_of_data_1 = test_data_1[:] # 拷贝test_data_1
 copy_of_data_2 = test_data_2[:] # 拷贝test_data_2

 bubble_sort(test_data_1)
 bubble_sort(test_data_2)
 copy_of_data_1.sort() # 把copy_of_data_1进行排序
 copy_of_data_2.sort() # 把copy_of_data_2进行排序

 self.assertEqual(test_data_1, copy_of_data_1)
 self.assertEqual(test_data_2, copy_of_data_2)


if __name__ == '__main__':
 unittest.main()

思考

大家可以思考下面一些问题

不服就来跑个分鸭

Tue, 17 Jun 2025 17:29:15 +0800

前几天跟朋友聊天的时候了解到python有个名为sanic的框架有着不错的性能。

一时技痒，于是顺便写了一些没有用的(这是真没有用的)hello world程序来跑个分，看看这个sanic框架是否真的是性能上佳。

这里我们用到的性能测试工具(跑分工具)是wrk，安装方便，使用简单，效率爆表，扩展性强，是http服务benchmark(跑分)的不二选择。

Flask

sanic看上去跟flask很像，当然了，只是看上去。没有对比就没有伤害，于是我便先开始对flask开始跑个分，以flask的得分作为基准，从而看看sanic对比flask在性能上是否有显著提升(这就是基准测试，划重点，面试可能要考的)。

先写个flask的hello world程序。

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/')
def hello_world():
 return jsonify(hello="world")

再跑起来。

env FLASK_APP=flask_test.py flask run

wrk去压一下。我其实压了几次，逐步加压，最后得到了一个最大的qps。

wrk -c 40 -t 10 http://localhost:5000/
Running 10s test @ http://localhost:5000/
 10 threads and 40 connections
 Thread Stats Avg Stdev Max +/- Stdev
 Latency 56.77ms 153.66ms 1.16s 95.32%
 Req/Sec 126.38 36.43 240.00 74.08%
 11442 requests in 10.06s, 1.79MB read
Requests/sec: 1137.51
Transfer/sec: 182.18KB

flask的qps就是1137，我们把qps当作得分，最终得分1137。

sanic

sanic出场。首先是祖传的hello world代码。

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route("/")
async def test(request):
 return json({"hello": "world"})

if __name__ == "__main__":
 app.run(host="0.0.0.0", port=12306)

运行起来

测试的各种类型你都了然于胸么

Tue, 17 Jun 2025 17:29:15 +0800

验收测试

进行这种类型的测试是为了确定产品的功能是否符合产品需求了。这通常涉及客户的反馈或具体的产品规格。

对于Web应用程序，可以通过模拟用户期望的行为直接使用Selenium来完成此测试的自动化。可以通过记录/回放或通过需求文档中说明的不同受支持的语言来完成此模拟。注意：验收测试是功能测试的子类型，某些人可能还会提到。

功能测试

进行这种类型的测试是为了确定产品的功能是否正常运行而没有问题。

这通常包括：系统可以正常运行（正确的重定向），没有错误（404，异常…），以及产品的实现符合需求的具体要求（请参见上面的验收测试）。

对于Web应用程序，可以通过模拟具体返回的方式直接使用Selenium来完成此测试的自动化。可以通过记录/回放或通过本文档中介绍的不同受支持的语言来完成此模拟。

性能测试

顾名思义，进行性能测试是为了衡量应用程序的性能。

性能测试有两种主要的子类型：

负载测试

进行了负载测试，以验证应用程序在不同定义的负载（通常是一次连接的特定数量的用户）下的运行状况。

压力测试

进行了压力测试，以验证应用程序在压力下（或高于最大支持负载）的运行状况。

通常，性能测试是通过执行一些Selenium用例来完成的，这些测试模拟了不同的用户使用Web应用程序的特定功能并收集了一些有意义的指标。

通常，这是由其他获取指标的工具完成的。 JMeter就是这样一种工具。

对于Web应用程序，要测量的详细信息包括吞吐量，延迟，数据丢失，单个组件加载时间…

注意1：所有浏览器的开发人员工具部分均具有“性能”标签（可通过按F12进行访问）

注2：是非功能测试的子类型，因为它通常是按系统而不是按功能/功能进行测试。

回归测试

该测试通常在更改，修复或添加功能之后进行。

为了确保所做的更改没有破坏任何现有功能，将再次执行一些已经执行的测试。

重新执行的测试集可以是全部或部分，并且可以包括几种不同的类型，具体取决于应用程序和开发团队。

测试驱动开发（TDD）

TDD本身不是测试类型，而是一种迭代开发方法，其中测试驱动功能的设计。

每个周期都从创建一组最终应通过该功能的单元测试开始（它们应该在首次执行时失败）。

此后，进行开发以使测试通过。再次执行测试，开始另一个循环，此过程一直持续到所有测试通过为止。

这样做的目的是基于这样的事实，即缺陷越早发现成本越低，从而加快了应用程序的开发。

行为驱动开发（BDD）

BDD还是基于上述TDD的迭代开发方法，其目的是让所有各方参与到应用程序的开发中。

每个周期都从开发一些需求开始（应该失败）。然后创建失败的单元测试（也应该失败），然后进行开发。

重复此循环，直到所有类型的测试通过。

为此就要使用领域特定的规范语言。各方都应该理解它，这种语言必须简单，标准和明确。大多数工具都使用Gherkin作为这种语言。

测试的目标是通过也针对潜在的接受错误，并使各方之间的通信更加顺畅，能够检测出比TDD甚至更多的错误。

当前有一组工具可用于编写规范并将其与代码功能（例如Cucumber或SpecFlow）匹配。

在Selenium之上构建了一组工具，可通过将BDD规范直接转换为可执行代码来使此过程更快。其中一些是JBehave，Capybara和Robot Framework。

原始封面

测试开发可以开发些什么

Tue, 17 Jun 2025 17:29:15 +0800

最近参与了公司级的测试项目评审，发现测试同学自主进行开发的项目很多，但也是有规律可循的，这里简单给大家分享一下目前我们可以看到的一些测试项目。大概分为下面几类。

api自动化测试类

这一类的项目很多，主要的目的是让api的测试更加高效，并与ci/cd结合，降低回归测试的工作量，并对接口做持续的测试和监控。

具体的套路有这样一些

api自动化测试框架，使用者通过go/python等编程语言进行用例的编写，持续维护用例库的增长；
api自动化测试平台。使用者可以用自然语言或者dsl进行用例编写，平台提供ui和用例执行方法，提升用例编写效率；
api测试工具类。比如支持私有协议转http协议的工具等，屏蔽一些技术细节和实现，让用例编写更为容易；

ui自动化测试类

这类的项目相信大家会比较熟悉，主要是通过ui自动化测试覆盖一些主要的回归场景，提升测试效率，降低人力投入。也可以跟ci/cd结合起来进行持续测试。

app自动化测试。通过脚本编写用例进行回归；
web自动化测试。通过dsl或者脚本进行用例的编写以及回归；

质量以及研发效率度量类

所谓的质量度量是指通过数据统计的方式对一段时间的测试/开发的质量进行度量，从而找出质量提升/腐化的原因，并进行相应的调整。通过一系列的指标标的出质量红线，从而持续监控质量情况。

常用的指标有

千行代码bug率
研发周期产生的bug
线上bug数
提测通过率

目前常见的bug管理平台可能无法比较方便的获取到上面的一些指标，因此需要进行二次开发，以便周期性的拿到上面的数据。

效率度量平台是度量研发/测试的效率，比如之前一个标准大小需求的开发上线周期是30天，在进行了一系列的效能提升和赋能之后可能会提升到25天。再比如之前回归测试的周期是3天，在进行了效能提升后周期缩短至2天。

这些平台的开发难度总体来说不大，另外产出的意义也比较明显。

流程管理类

定制研发生命周期中的各种流程，比如用例评审流程，提测流程，发布流程等，做到流程透明，可控，规范，统一，流程中的产出物清晰合规，流程参与者方便对流程进行推动和复盘。

这类需求的产生是因为每个团队的研发周期总是有一些定制性的场景，常见的普适性的流程管理工具可能没有比较好的方式进行定制和满足。

测试支持工具

这类工具最灵活也最有意思，小而美，能有好用是主要目标。

比如通过用户id生成鉴权token的工具，简单的文字识别工具等。

总结

测试开发领域目前总的来说处于瓶颈期，后面新技术和新思路的引入可能会带来不一样的感觉和惊喜。

原始封面

测试妹子们的朋友圈到底长什么样子？

Tue, 17 Jun 2025 17:29:15 +0800

因为工作和分享的关系，我的微信里加了一些测试妹子，没仔细数，几十人应该是有的吧。今天就不妨带大家看一下测试妹子们的朋友圈到底是什么样子的吧。

下面的展示照片均已经过本人同意。

美人如花隔云端

作为妹子，朋友圈里晒美照自然是天经地义的了。

既有闲来无事的自拍，也有出游之余的惊鸿一瞥，不禁让人感叹，一颦一笑皆含情，淡妆浓抹总相宜。

稚子阶前戏

有时候在工作中，测试妹子会开玩笑说自己是被测项目/产品的老母亲，为各种问题操碎了心；在生活中，妹子们在家中也是母仪天下，尽管有时候抱怨带娃不易，但在朋友圈晒娃的时候，大体应该是心情舒畅的吧。

狗吠深巷中，鸡鸣桑树颠

在城市中养鸡需要太多的硬核技能，往往都能把鸡养成段子，所以一般情况下不会有人尝试了。

不过养犬吸猫的却是大有人在。

很多测试妹子都喜欢在朋友圈晒猫猫狗狗，经常会被各种萌到。

我们公司就有专门的宠物群，我猜里面的开发/测试/产品妹子应该是数量不少的。

猫犬相闻，岁月静好。

缓歌慢舞凝丝竹,尽日君王看不足

有些妹子平常在工作中可能不显山不露水，但在生活中却是各中高手，深藏不露。

有健身达人，一口气跑个几公里只能算是健身，也有绘画大师，令人印象深刻，还有舞林高手，舞低杨柳楼心月，歌尽桃花扇底风。

生命不息，代购不止

我开动我记忆力秃出的大脑，搜肠刮肚也找不出一句古诗来跟代购沾上边的，所以标题里混入了一些奇怪的东西。

应该加了不少的开发(汉子为主)和测试同学(汉子妹子都有)，测试妹子的代购信息在朋友圈里还是配的上一席之地的。

其实也好理解，很有妹子对测试这个职位有天生的不安全感，提前布局代购市场也算是为今后的华丽转身埋下伏笔，另外可能测试妹子拿的确实不算多，需要发展一些其他的选项来补贴家用。

青浮卵碗槐芽饼，红点冰盘藿叶鱼

读万卷书，行万里路，吃百家饭。美食和旅行是朋友圈永恒的话题了，测试妹子们的足迹也是遍布天南地北，经常也有舌尖上的中国的既视感。

最后

其实测试妹子们的朋友圈跟普通人的朋友圈差不太多，宠物，亲子，旅行，美食，撒狗粮，业余爱好，并不能免俗。可能会偶尔抱怨一下工作的烦恼，感叹一下生活的不易，但生活总在继续，在平淡中寻找短暂的快乐，用镜头去抓住美好的回忆，时间白驹过隙，把跟自己梦想中的生活接近的瞬间留在朋友圈里，别人欣赏也好，鄙夷也罢，我的生活，也许与各位看客并不相关。

测试是一份工作，工作永远只是生活的一部分。尽管妹子们的朋友圈偶有戾气，但我看到更多的是快乐，情趣，从容，平静。这大概是因为做测试工作确实是需要保持良好的心态吧。

总之测试妹子们的朋友圈是生活的，接地气的，真实的，也许是职业习惯的关系，妹子们朋友圈的错别字似乎特别的少，选图也更为严谨，意识流的情况很少发生。嗯，说到错别字，连文章标题都会写错的我秃然陷入了沉思。

原始封面

测试人，请珍惜自己的生命吧

Tue, 17 Jun 2025 17:29:15 +0800

最近对于大部分人来说，是很艰难的一段时期。

前几天听说有位测试同学选择了自己结束生命，就在30岁左右的黄金年龄。

事情的详细情况我并不清楚，只是大约知道他之前心气很高，现在有抑郁症，最后在隔离的那段时间选择离开这个世界。

RIP

在群里跟大家聊起这件事的时候，有几个同学说他们有焦虑症，心悸，失眠，脱发，整天没有精神。

秃然想起几年前，我似乎也有类似的情况。

那时候压力很大，每天吃不好，睡不着，做梦都在写代码。早上5点就醒，醒来第一件事就是打开电脑写代码，不过我没意识到那是焦虑，过了一段时间功能发布之后，自然而然的就好了。

后来有一阵子带了几个项目，外部压力很大，但是内部资源紧张，很难达到领导定的指标，那段时间每天晚上几乎都是失眠，担心项目没办法达到预期，绩效很差，最后连累了大家。最终到底是不堪重负，我还是选择离开。没有了不切实际的压力之后，焦虑自然而然就好了。

作为过来人，我想，我们的焦虑或者抑郁大概来源于这些方面吧。

外部巨大的压力

我是赞成有适当的压力的，没有压力往往就会没有动力，失去前进的方向，但我不赞同巨大的压力。

有人喜欢拿小草在春天发芽的例子来类比压力，说野草有韧性，哪怕地面上有一块石头，它也能坚韧不拔，从缝隙里破茧而出。这就证明只要自己足够努力，哪怕再大的压力，我们都能克服。这就有点耍流氓了，如果地面上覆盖的是几十吨的钢筋水泥，我想再坚强的野草也只能频繁的呼喊自己的名字，并不能茁壮成长吧。

现在大部分企业的KPI文化，有时候就是把压力放大的工具。合理的KPI能带来动力，这点我承认，但很多时候KPI可能变成了政治工具和隐暴力的压迫手段，一些KPI放的比卫星还高，明显就是完成不了的，这时候除了给当事人带来焦虑和无助之外，对整体的业绩也许并没有多少帮助。

人的能力在某段时间内是有限的。一些不切实际的KPI看起来是积极向上的，令人感到努力一下是可以达到的。但这种流氓KPI往往忽略了时间因素，欠下的债最终只能通过各种福报来偿还了。

努力让自己变强吧，这样暴力KPI下来之后，你可以说我做不到。你都做不到那别人更做不到，就算有人怼你说做不到就换人，那他换就任他换吧，毕竟他也换不到更好的。

自身的巨大压力

我努力奔跑只是为了追上曾经被寄予厚望的自己。

我的生活不应该只是现在的这个样子。

这些想法其实都没错了，不过还是要加上时间因子。很多事情不能一蹴而就的，缩短了时间，就会给自己带来的瞬时压力，最终导致崩溃或放弃。

不如这样想。

我这么多年(10年20年一辈子？)努力奔跑只是为了追上曾经被寄予厚望的自己。

我的生活不应该只是现在的这个样子，我会持续努力(10年20年一辈子？)，从而让自己和家人过的更好。

我要偷偷的努力呀(10年20年一辈子？)，最终惊艳这个世界。

所以我们不要一阵子突然努力，而是要坚持下去，春风化雨，持之以恒。

纷繁的各种压力

柴米油盐酱醋茶，吃喝住行，凡是要花钱的地方有时候都会给我们带来焦虑和压力，毕竟入不敷出多少是会让人产生不适感的。

这里其实大家不用被消费主义的一些说辞给带偏了，能不买的就不买，买了用不上几次的也不买，能提升自己的钱就花，只能给自己带来短暂满足的就一毛不拔，这样先节流，以后再想办法去开源好了。

举个例子，有一阵子我很想办个健身卡，比如是2000块一年。综合考虑到我工作很忙，经常早上6点多出发，晚上10点到家，周末我还要上课，所以我一年能挤出100天去健身房就已经很不错了。然后再考虑到临时有事，各种不便，自己懒惰的因素，我能去20次就不错了。这样算下来每次去要100块钱，不划算，坚决不办。

另一个例子，我要买台macbook pro, 8800。我每天都会用到，学习也好，工作也罢，mbp至少能用5年，这样算下来8000 / 365 / 5 = 4.3。大概每天4块钱，不算特别贵，可以考虑分24期免息买一个。

理性支出，缓解焦虑，提升自己，为以后的开源带来可能。

另外我们也有一些可以缓解压力和焦虑的办法。

早睡早起

睡的早，第二天都会快乐不少。

坚持运动

偶尔运动我觉得有时候会很痛苦，不过如果是经常运动的话，每次运动都会很开心。

可以去爬山，徒步，骑车，打球，选择很多。

培养一个爱好

有的同学喜欢读书，读书可以让人快乐。

有的同学喜欢玩魔方，指尖的速度和激情。

我前两年花在路上的时间很多，于是学会了吹口琴，也算是塞翁失马，失之东隅，收之桑榆。

去年因为带娃逗娃，学会了尤克里里的弹唱。偶尔玩一下乐器还是让人心情舒畅不少的。

少刷信息流

一些信息流，短视频也好，各种自媒体文章也罢，总是无意间贩卖焦虑，或者让人攀比。这时候信息闭塞一点也许更好，毕竟自己的生活往往不需要陌生人进来参合。

我应该也算是曾经焦虑过，抑郁过。一个有着相同经历的生命的离去让人唏嘘和惋惜。

哀悼的同时，我还是期待着这个世界。

 曾经我也想过一了百了
　　就因为看著海鸥在码头上悲鸣
　　随波逐流浮沉的海鸟啊
　　也将我的过去啄食 展翅飞去吧
　　曾经我也想过一了百了
　　因为生日那天杏花绽放
　　在那筛落阳光的树荫下小睡
　　大概就会像未能转生的虫 就此适应於土里长眠了吧
　　薄荷糖 渔港的灯塔
 生锈的拱桥 被丢弃的自行车
　　杵立在木造车站的暖炉前
　　心却哪儿都不能就此启程
　　今日和昨日相同
　　想要更好的明天 今天就须有所行动
　　我知道 我都知道 但是
　　曾经我也想过一了百了
　　因为心早就被掏空
　　心不能被填满的哭泣著
　　因为我仍渴望著什麼
　　曾经我也想过一了百了
　　因为那松开的鞋带
　　我无法好好将它系紧
　　如同不懂得系紧某人一般
　　曾经我也想过一了百了
　　因为少年凝视著我
　　跪著在床上谢罪吧
　　向过去的我说声抱歉
　　电脑透出淡淡的光
　　楼上房间传来的动静
　　门口对讲机的声音
　　困在鸟笼中的少年捣住耳朵
　　与无形的敌人战斗著
　　他是三坪房间里的唐吉诃德
　　最后的结局 却是抖丑陋不堪
　　曾经我也想过一了百了
　　因为有人说我是冷漠的人
　　想要被爱的哭泣著
　　是因为终於尝到人间温暖
　　曾经我也想过一了百了
　　你美丽的笑著
　　满脑子想著自我了结
　　终究因为活著这事太过於刻骨
　　曾经我也想过一了百了
　　我还没有遇见「你」
　　因为有像你一样的人存在
　　我稍稍喜欢上这个世界了
　　因为有像你一样的人存在
　　我开始稍稍期待著这个世界

原始封面

测试同学必会系列之如何进行幂等性的测试

Tue, 17 Jun 2025 17:29:15 +0800

很多同学都应该听过幂等这个概念，但如果在面试中真的被问起来什么是幂等，你有信心去解释清楚么？

首先看看幂等的定义。

一个HTTP方法是幂等的，指的是同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。在正确实现的条件下，GET，HEAD，PUT和DELETE 等方法都是幂等的，而 POST 方法不是。所有的 safe 方法也都是幂等的。

幂等性只与后端服务器的实际状态有关，而每一次请求接收到的状态码不一定相同。例如，第一次调用DELETE 方法有可能返回 200，但是后续的请求可能会返回404。DELETE 的言外之意是，开发者不应该使用DELETE方法实现具有删除最后条目功能的 RESTful API。

需要注意的是，服务器不一定会确保请求方法的幂等性，有些应用可能会错误地打破幂等性约束。

是不是有点抽象？

再看看英文的定义

Idempotence (UK: /ˌɪdɛmˈpoʊtəns/,[1] US: /ˌaɪdəm-/)[2] is the property of certain operations in mathematics and computer science whereby they can be applied multiple times without changing the result beyond the initial application. The concept of idempotence arises in a number of places in abstract algebra (in particular, in the theory of projectors and closure operators) and functional programming (in which it is connected to the property of referential transparency).

测试同学的打怪升级之路

Tue, 17 Jun 2025 17:29:15 +0800

上面是某大型互联网公司某部门定义的测试同学能力模型。

大体上这个能力模型将测试同学分成了4个等级，分别是1级到4级，其中1级能力最弱，4级最强。

在打怪升级的途中，该模型还定义了一些技能点，分别是

测试用例：大概是指用例的设计能力吧
探索性测试：应该是指的测试经验，有经验才能探索，毕竟探索性测试又叫老司机测试
测试自动化：大概是指的测试效率这块，通过自动化技术去提升测试效率
分析定位：帮开发定位bug
后台开发：后台开发能力。为什么没有前端和客户端开发呢？所以这个应该改成开发能力会更合理一点
创造力：顾名思义了

每个级别都对应了6个不同维度的指标描述，作者水平有限，觉得密密麻麻的文字看得不是特别清晰，所以斗胆用一些简单的关键字来概括一下，一家之言，不用过分解读。

第一级：入门学习模仿

测试用例设计需要入门
探索性测试在有经验同学的指导下可以完成
测试自动化维护现有的东西
尝试一下分析定位
学一些开发技能
不要求创造力，但要有能力去模仿

第二级：独立担当熟练

独立设计用例，要求熟练
独立探索
独立做模块级的自动化测试
努力分析定位
掌握一些基本的技术技能
可以独立工作和成长了

第三级：精通深入独当一面

用例方面要对质量结果负责，就是说以前是一个人在战斗，现在是要带领大家战斗
业务熟练
框架级的自动化测试开发
精通某个方向的分析定位
具有架构能力
有优秀的创造力

第四级：兼济天下高屋建瓴格局

测试专家
业务专家，并且可以指导他人
自动化做成体系
开发专家，基础扎实
架构专家
指导力max

前两级个人是觉得中规中矩的，没有太多的分歧。第三级其实就是带管理责任的测试专家，有点问题，但至少逻辑上是可以自洽的。第四级基本上属于斗战胜佛，江湖很少有此类的传说，最简单的反驳逻辑就是都有这个能力了，做点啥不好，为什么还要做测试？

所以当我第一眼看到这个图时，我觉得前两级是我们可以去企及和努力的。第三级看机缘，第四级有点玄幻，大家看看就好。

总之测试同学打怪升级之路是有方向的，满级之路比较遥远，我们一起加油。

原始封面

测试同学如何学习前端

Tue, 17 Jun 2025 17:29:15 +0800

最近发现很多测试同学有学习前端开发技术的需求，理由无外乎如下

前后端分离以后如果不了解前端技术那么测试起来可能找不到问题的症结所在
一些测试工具需要前端展示和操作，因为测试工具的前端操作可能比较复杂，所以一般会选用前后端分离的方案去专心搞前端
专业前端越来越多，不会一点前端技术可能都不好交流

总路线图

好了，看到路线图可能大家觉得凉凉了，其实不用怕，那测试同学怎么学前端呢？这里推荐一条相对路径较短的线路

知识储备阶段

我们首先要把前端知识的粗略的过一遍，不要求全部弄明白，起码混个脸熟。

* 学习html语法，最好能自己手动写一些静态的页面，丑一点没关系

css基础，主要是学语法和布局，不需要纠结与细节和动画
JavaScript基础，主要是学语法，操作dom
要了解什么是Ajax以及如何用代码发起ajax请求，如何在浏览器里查看ajax请求
如果对web ui自动化很感兴趣，可以学习jquery

进阶

学会使用1个package manager，比如npm/yarn
学会使用package manager与安装依赖
学习css预处理器，比如sass/PostCss等
学会使用1个css框架，比如bootstrap/bulma之类

继续进阶

学会使用构建工具，比如webpack/rollup/parcel/gulp/npm scripts/eslint等
学习1个js框架，比如react/angular/vue
学会使用某个js框架做1个todo list。这个github上有同名项目，大家可以搜索一下

基本上到这里对于入门来说就差不多了，要学的东西看上去很多，但实际上却是比较聚焦的。

根据经验，大家一般会在知识储备阶段放弃，毕竟万事开头难。

其实大家可以使用目标导向的方式，比如给自己定个目标，3个月以后看懂todo list的源码并自己实现1个，那么学起来可能会有更多动力。

点击阅读原文可以查看todo list的源码。

原始封面

测试同学是否需要买一台mac

Tue, 17 Jun 2025 17:29:15 +0800

前几天我卖掉了跟随我多年的macbook pro 15。

如果没记错的化，那应该是我2013年左右购入的，应该是第一代使用retina屏幕的macbook pro版本。

掐指一算，这台电脑已经使用了7年。处理器是第4代i7，内存8g，硬盘256G，现在用起来速度还是比较快速的，跟我办公用的16款macbook pro速度差不太多，只是因为公司标配了mac，家里的2013款mbp出场率实在有限，不得不忍痛先出掉了。

这台mbp当时是我为了学习ios开发而购入的，后来稍微学习一段时间过后，转岗成为了一名ios开发工程师，也算是得偿所愿。

后来又在这台机器上捣鼓ruby/python/js等一系列语言，期间接了一些私活，算来早就已经回本了，现在出掉给它找一个好归宿，在他人手上继续夕阳红，也算是一个标准的快乐结局。

那么话说回来，测试同学是不是需要买一台mac呢？

其实这个问题并没有什么标准答案，购买与否还是要看自己的需求。

分享一下我当时的心路历程吧，时隔多年记得不是很清楚了，模模糊糊的记得有下面的原因

我想要有一台mac，因为当时去参加一些ruby的线下交流会，发现大家都是拿的mac，无形中种草了
当时ios的开发很火，没有mac就没办法做ios开发，而我想学一下ios开发，不如买一台吧
ruby的整套开发环境在mac上部署比较友好，我正好会一点点ruby开发，有台mac会好一点
15寸的mac开始标配retina屏幕，显示效果惊艳，正好会一点点ps的我还是有一丢丢需求的

作为一个7年来一直使用mac作为主力办公/学习设备的中老年人，我列出一些场景，作为大家购买的参考

我想学习一门脚本语言，比如python

如果只是想学习一门脚本语言，不考虑做一些正式的产品或项目的化，用windows也是没问题的，毕竟只是学习，入门级的使用，mac和windows并没有太大区别。

不过如果你有深度的python或其他脚本语言的使用需求的化，mac可能是更好的选择了。因为python的一些第三方库可能只支持linux或mac，windows是鞭长莫及的。

总之，入门级的学习，买不买mac都可以。

我想学习linux命令

纯粹学习linux命令的话，可以在windows上安装一个虚拟机，或者win10似乎已经自带ubuntu了，用windows学的话问题也不大，又或者花一点钱买一台云服务器，速度更快，还有公网ip，能折腾出更多花样，参考我之前用siri做自动化测试的文章。

mac的命令跟linux是差不多的，如果你学会了在mac中重度使用terminal，那么linux你就自然会了一些了。

如果只是单纯学习linux，云服务器应该是最佳选择。

我想学习ui自动化测试

如果只是学习selenium，那么windows是没有问题的。

在mac上跑selenium速度会更快一点，但周边生态相比windows其实并没有质的提升。

我想看电影打游戏

我很少在mac上看电影，所以机器上也只装了vlc播放器，这个播放器易用性一般，但是功能强大，基本上大多数格式都支持，不过不知道是不是我的错觉，总感觉播放一段时间以后mac会发烫。

如果你只是在网页上看视频或追剧的话，mac的chrome非常消耗系统资源，而且基于flash的播放器插件会让你的mac跟电饼档一样，弄一套煎饼果子是问题不大的。如果用safari配上html5的播放器，这个问题基本上可以解决，不过国内很多视频网站只支持flash播放器，这时候老老实实使用windows才是明智之举。

steam平台支持mac，按道理说可以玩一些dota2之类的游戏了，我没在mac上玩过游戏，所以mac的游戏体验如何我是没有主观感受的，不过从各种渠道得到的反馈大体上都是mac其实并不适合玩游戏。

我想修图/剪辑视频

mac支持adobe全家桶，用ps修个图啥的问题不大，不过很多mac机型没有独立显卡，这点是需要注意的。

mac自带了imovie软件，用来做简单的视频剪辑是一个不错的选择。

另外mac自带了库乐队应用，可以用来做简单的编曲。

不过这些事情windows/ipad也全都可以做了。

我只是简单办公上网

mac自带了免费办公三件套，numbers/keynote/pages，跟office功能差不多，甚至更强大，这点keynote的重度用户罗老师就很有发言权。

safari浏览器在mac上反应迅速而且资源占用少，在用电池的情况下，我曾经一台macbook air用safari可以连续上网10小时左右，续航能力真的很强悍。

当然windows电脑办公上网也不在话下了，mac其实并没有巨大的优势

我想在星巴克拿出一台可以用一天的电脑

这点我是推荐mac的，颜值高续航能力强，星巴克的绝佳伴侣。

我想获得更好的用户体验

mac的触摸板是一种用了就回不去的东西，基本秒杀一切windows笔记本的触摸板。

如果你追求美感和更好的用户体验，那么mac是不错的选择。

总结

从学习/生产力工具的角度总结一下，mac有这样一些优点

基本兼容大多数的linux软件，适合做初学/深度的编程工作
有着专业完备的软件生态环境，比如音频/视频的制作，专业性非常强
打游戏体验不好，适合聚焦在学习或者生产上
系统相对稳定，体验更好

mac的缺点也很明显

贵
软件贵
硬件周边贵
有一些windows可以做的事情mac就是做不到，比如使用ie打开网银之类的

那么我该买什么型号的mac

如果你想选择一款mac，那么

没有移动的需求可以选择mac mini，毕竟是最便宜的mac产品
只是办公上网，追求续航和轻便，那么可以选择macbook air
啥都想干一点，追求均衡，那么macbook pro会更合适
专攻设计，屏幕一定要好，imac的5k屏幕也许是个不错的选择
性能怪兽，追求极致又不差钱，mac pro了解一下？

根据经验，mac mini的吃灰率应该是最高的，macbook air因为散热的问题，在某些时候会比较烫，macbook pro应该是需求最不明确时候的较好选择。

测试同学需要了解的redi的常见使用场景

Tue, 17 Jun 2025 17:29:15 +0800

Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。

键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。

Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。

Redis的使用非常广泛，是测试同学需要了解的中间件之一，对我们设计测试场景和定位问题有比较大的帮助。

Redis的基本特点

读写速度快：比一般的数据库快
可以持久化：尽管redis可以持久化，但是不使用其持久化的场景也很多

Redis的数据类型

STRING: 字符串、整数或者浮点数，对整个字符串或者字符串的其中一部分执行操作，对整数和浮点数执行自增或者自减操作
LIST: 列表，从两端压入或者弹出元素,对单个或者多个元素进行修剪，只保留一个范围内的元素
SET: 无序集合
HASH: 包含键值对的无序散列表
ZSET: 有序集合,添加、获取、删除元素,根据分值范围或者成员来获取元素，计算一个键的排名，这个是支持排序的

使用场景

计数器：比如某公众号推送一篇文章给几千万的粉丝，我们需要记录阅读量。由于每个用户都会产生一次的阅读记录，假设有上万的用户在同1秒产生了阅读数，那么1秒要写入上万次，对于数据库来说这个写入次数是比较巨大的，会带来比较大的性能压力。这时候就可以把阅读数先保存在redis里面，由于redis的吞吐量比较大，扛住的可能性会更高一些。等数据写入的差不多了在持久化到数据库就好了；
缓存：将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。比如站点的一些全局配置，每个用户都需要来拉一次，而且内容变化的频率很低，如果放数据库的话会对数据库宝贵的计算资源造成浪费，所以可以放到redis里，用户去redis缓存里读，降低了对数据库的访问量的同学要加速了配置拉取的速度；
查找表：例如 DNS 记录就很适合使用 Redis 进行存储。查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
消息队列：List 是一个双向链表，可以通过 lpush 和 rpop 写入和读取消息。比如可以把发送邮件的场景，因为邮件服务器的qps一般来说都不是特别高，如果同时发送很多邮件的话，对邮件服务器可能产生很大的压力。我们可以把邮件发送的消息放到redis里，让邮件服务器从redis一个接一个的读取和处理。不过更专业的消息队列场景最好使用 Kafka、RabbitMQ 等消息中间件。
会话缓存：可以使用 Redis 来统一存储多台应用服务器的会话信息。应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。简单来说可以把登录态的一些信息也放redis里。
共同好友： Set 可以实现交集、并集等操作，从而实现共同好友等功能；
排行榜： ZSet 可以实现有序性操作，从而实现排行榜等功能；
限制验证码的发送频率：一般我们收到短信验证码的时候，应用都会限制说60秒之后重新获取，这是为了防止有人恶意刷短信验证码，毕竟发验证码是要花钱的。用redis可以非常方便的实现这个功能。我们可以把用户id记录到redis里，并设置过期时间是60秒，这样60秒内用户再请求发送的时候就会发现该用户的发送记录已存在，60秒以后由于缓存自动过期，那么就可以重新再发送了；

以上是redis的一些非常简单的使用场景了，有兴趣的同学可以跟开发同学再多探讨一下自己业务里redis的具体使用方式。

原始封面

测试同学需要了解的序列化和反序列化

Tue, 17 Jun 2025 17:29:15 +0800

经常看到有同学弄不清楚序列化和反序列化，从而造成了很多困扰。

从工作上的现实意义来说，了解序列化和反序列化是相当有必要的，在一些场景下可以指导测试用例的编写，另外也可以帮助我们了解被测产品/项目的一些实现细节。

定义

序列化(Serialization)

In computer science, in the context of data storage, serialization (or serialisation) is the process of translating data structures or object state into a format that can be stored (for example, in a file or memory buffer) or transmitted (for example, across a network connection link) and reconstructed later (possibly in a different computer environment).

简单来说，序列化是一个过程，是把一些数据结构或对象转换成是可以存储(比如保存到文件，内存，数据库)或者是可以传输(比如网络传输)的格式。当然，这个格式的数据是可以反过来还原成数据结构或对象的。

是不是有点绕？举个具体的例子。

For an everyday example, say you want to tell your friend over the phone about your puppy. You are not able to send the entire living dog over the phone, but are restricted to describe the dog in a format that can be conveyed over the phone, in a serialized form: You say “It’s black, small, 5 months old…” Your friend will then deserialize the information into a form that is feasible on his side: a mental image of the black, little dog. Likewise, a computer program cannot just send its compiled objects to another computer - objects from a Windows compiler won’t do on MacOS for instance. Instead it serializes the object MyPuppy to an XML or JSON string ({“color”:“black”, “size”:“small”…}) that can be sent and easily interpreted, or deserialized, into another system’s dog object as a black, little puppy.

测试同学学历不好应该怎么办？

Tue, 17 Jun 2025 17:29:15 +0800

我写东西的灵感经常来源于群聊或者，嗯，还是群聊。

最近的因为事情特别多，基本上是没时间聊天的了，灵感有一些青黄不接，不过今天秃然想到了一个可以跟大家分享的点。

那就是测试同学学历不好怎么办？

事情的经过是这样的。因为我们公司最近在大量招聘，所以我通过一些方式去收集了部分简历，但是这些简历大部分都被hr给pass掉了，深究其原因，无非就是学历不过关。

我们公司基本上是个小公司，知名度一般，跟一线大公司比，其实学历要求相对还是低一点的。不过今年明显可以感到，我们对学历的要求开始水涨船高。之前二本可以通过hr删选，现在则要求一本及以上学历。简而言之就是211985的本科以及硕士以上学历以及相关专业。

这种要求基本上挡住了80%左右的求职者。为什么呢？

很大一部分测试同学的学历其实不算特别有竞争力

长江后浪推前浪。最近b站特别火的后浪视频就说明了这一点。对于从业比较早的测试同学来说，很多同学可能是大专/专升本/三本的学历。在当初，也就是前些年，这些学历去找一份测试的工作可能不难，不过现在应届生越来越多，行业岗位其实并没有爆发式的增长，就造成了后浪跟前浪一起竞争的情况。后浪的学历水平很可能是高于前浪的，毕竟现在高考升学率其实比之前可能是要高的，毕业生的绝对数量也比之前要大，真的拼学历，后浪应该有一些优势。

很多测试同学不是相关专业

众所周知，很多开发/测试同学是培训机构出来的，这些同学可能往往不是计算机相关专业，而一些一线互联网企业其实很看重相关专业，毕竟好的基础代表着更大的提升空间。

当然我说这些其实不是让大家增加焦虑，只是说明很多情况下，就业的压力和上升的通道可能跟这些因素有关系。但事在人为，我觉得测试同学是有不少的努力方向可以持续提升和自我发展的。毕竟专业不能代表一切，学历也只是一个快速过滤的选项。

如果大家学历不够，或者不是相关专业，那怎么进行自我提升呢？

之前看到过一个老外对于程序员成长的建议，我觉得是有参考价值的。

原文在这里。

As a developer, your 9-5 shouldn’t be your sole focus.

Find time for projects outside your regular job:

- Write blog posts
- Attend conferences
- Build something just for fun
- Network with other developers

Expanding in this way leads to huge opportunities.

开始写博客吧

写博客意味着总结，有总结就有提升。之前有位同学学历也是一般，后来他坚持写博客，终于在面试的时候产生了效果，于是职业生涯迎来了一些新的机会。他还专门私信跟我说了这件事，我也是衷心为他感到高兴。

另外虫师也是很好的例子，起点不高的他通过博客记录了他的技术成长过程，也通过博客帮助和鼓励了很多人。

有稳定的输出的博客会给面试官带来候选人有独立思考和持续学习的印象，是不错的加分项目。

做一些自己感兴趣的项目

我是强烈建议测试学习一些开发能力的，这样与开发的沟通会更顺畅一些，也不会被开发技术降纬打击，说人话就是不会被忽悠。

我就学过很多技术，但性价比最高的还是基础的东西，因为越基础的东西变化的可能性越小，学一次可以用十几年，何乐而不为。

哪些东西是基础的呢？

操作系统的原理
网络原理
算法

看起来越无聊的东西其实越基础，有趣的东西往往都是应用了。这里知道为什么大家喜欢招相关专业了吧。

测试同学可以结合自己的工作，做这样一些有意思的项目。

沉迷折腾，无法自拔

Tue, 17 Jun 2025 17:29:15 +0800

最近在抽屉里翻出了某品牌的一个专业运动手环，应该是之前跟该品牌合作的时候甲方大大赠予的。正好最近一直在关注iwatch，于是就桃僵李代，把手环当iwatch来用吧，反正功能也差不太多。

带上去以后的几天，感觉还是很不错的。

首先是翻腕亮屏功能，这个功能基本保证了这个手环可以当手表用，正好我以前有戴表的习惯，只是因为祖传的那块表时间总是不准所以放弃了，这次也算是无缝衔接了；
记步功能。戴了手环以后发现我每天差不多要走7000步，挺有成就感的。不过ios的健康app里也有同样的功能，只是因为要打开app查看，所以很多时候就忙忘记了；这次天天在手腕上进行提醒，实用性增强了很多；
心跳监控。实话实说，没啥用。
防水功能，这个是必须的，我有时候洗澡都戴着，完全没啥问题。
超长待机。一天10%的电就够了，大概2周一充，比iwatch强一些。
睡眠监控。不用不知道，一用吓一跳。用了以后才发现原来自己的睡眠质量那么差，每天深睡的时间非常短。

关于手环的睡眠质量

一天好多天，我都被手环检测出的睡眠质量困扰。

其实我身体上没有特别明显的缺觉感觉，但是手环却告诉我，你的睡眠质量差，需要改进。

我直觉上感到应该研究一下手环检测睡眠质量的原理，简单查了一下，发现手环是根据运动感应和心跳来判断是否是深度睡眠的。

简单来说就是，如果你睡觉的时候没有翻身而且心跳频率变低的话，那么手环就认为是深睡，反之就是浅睡。这样如果睡觉不老实的人，比如频繁翻身之类的，那么得出的睡眠质量一定是不高的。

所以手环的值只是参考，它不代表你睡的好不好，它只能证明你睡觉老不老实。

所以睡觉监控，看看就好，不要往心里去。

也终于想起了当年为什么不戴这个手环了，因为当年也是频繁显示我睡眠质量低，为了免去烦恼，还是不戴为好。

提升睡眠质量

当然，尽管嘴上说值只是参考，但我身体上还是很诚实，我查了一下如何去改善睡眠质量，下面是我从某视频网站的高点击率视频里学到的技巧。

睡觉前10小时不要摄入咖啡因。这个简单，因为我不喝咖啡；
睡满8个小时，而不是在床上躺8小时；这条放弃了，我大概7个小时就会醒，勉强不来；
睡觉前1小时不看任何的屏幕，比如手机/pad/电脑。这点只能说尽量做到，因为睡觉之前还是会看一下手机消息和告警的；

简而言之，睡觉之前不要玩手机，可以看看书，做一下拉伸之类的。但道理我们都懂，做到确实太难。

提升音质

因为经常需要录制教程，所以对于录屏和录音我还是自认较为熟悉的，直到近期有一天我用耳机听之前录制的视频，我惊奇的发现声音质量原来这么差，不仅底噪高，而且声音的还原度也很差。

于是我决定要提升课程直播和录制时的声音质量。

经过调研，我发现比较靠谱的方式是弄个外置声卡，而后接个心型指向的电容麦，这样应该就可以有较大的改善了，具体效果应该是这个样子的。

不过这套装备的问题是占用的空间比较大，而我的桌面空间有限，放这套装备有点勉强。

于是选来选去，我决定使用录音笔+胸麦的方案，我买的是zoom的h1n录音笔，pdd大概600块左右，送一堆配件。

这个录音笔的玩法比较多，比如

直接连电脑作为声卡+外接麦克风
支持连接其他外接麦克风
支持直接录音，录制乐器的还原度很高，音质在线
支持连单反作为单反的外接麦克风使用
支持连手机作为手机的外接麦克风使用

所以胸麦+录音笔的组合满足了我直播/录播的需求，还满足了我录制乐器声音的需求，一举两得，目前看来是行得通的。

不过由于我家附近的噪声比较大，每次直播的时候我都会把麦克风的增益调小，这样可以比较好的控制背景噪音，但是带来的问题是录制的视频声音比较小。

为了解决这个问题，我使用ffmpeg+audacity来做声音后期。

步骤是使用ffmpeg把声音分离出来放到audacity去做降噪/标准化/提升音量等处理，然后再把处理好的声音用ffmpeg合并到之前的视频里去，基本上几条命令加几个宏操作就好了，复杂度不高，效果目前看来是可以的。

学习剪辑

十一出去玩的时候拍了很多娃的视频和照片，这里就需要剪辑一下，变成游记vlog，优化回忆。

之前的剪辑都是使用imovie，简单实用而且免费，不过只能用在mac上，而我的mac经常放公司不带回去，家里只有一台祖传的windows笔记本，所以我需要找到在windows进行免费的视频剪辑方案。

研究了很多前人的推荐以后，我这里试用了3个软件

Davinci relove: 专业的剪辑工具，学会以后基本上啥都能搞定，据说好莱坞大片也用这个工具剪，学习成本高，但是收益也大，关键是免费，绝对神器；不过因为我的笔记本配置实在太差，所以放弃了；
Blender: 专业的3D动画建模工具，视频剪辑只是辅助功能，不过完全够用，免费，推荐；
Openshot: 免费简单的剪辑工具，基本的剪辑字幕和加转场可以轻易实现，快捷键很好用，不过没有调色功能，而且项目复杂一点各种调整都很麻烦，但简单的视频用来剪剪是完全没问题的；

都9102年了，是时候该学会python了

Tue, 17 Jun 2025 17:29:15 +0800

写在2019年的尾巴。

2019年11月的编程语言排行榜上，python排名第3，前5名的排名分别是

java
c
python
c++
c#

python是排名前5的语言里唯一的动态脚本语言，而且python是2007/2010/2018年的年度编程语言，该语言的流程程度不言而喻。

对测试同学来说，学会一门编程语言基本上属于必备技能了，这点应该争议不大了。python应该是众多编程语言里比较平易近人的一门，所以是推荐大家优先学习的。

另外前几年看到过一本书，叫做«python for kids»，小孩子都在学python了，咱们社畜也不能太落后了吧。

关于python在测试中的应用，这里就不一一列举了。在这里给大家推荐一些不错的学习资源和线路图，希望对大家有所帮助。

众所周知，掌握一门语言不在于学，而在于练，所以测试同学学python不能仅仅停留在看语法学关键字的层面，更重要的是要动手去敲。

step 1: 动手敲代码去学习语法

尽管在掌握一门语言之后，语法就不是特别重要了，但在学习语言的初期，语法却是大多数同学的拦路虎。

看语法始终是纸上得来终觉浅，比如开车，学了交规做题得了一百分不代表你能把车开好。语法还是一边练一边学比较好。

学习python语法推荐《learn python the hard way》的最新版，中文翻译过来是笨方法学python。

这本书深入浅出，每一章都有完整的例子，你可以先不看具体的解释，而只是把里面的代码敲一遍，运行起来，解决完各种缩进，拼写错误问题之后，python语法就大致可以掌握了。

如果一遍掌握不了，那就再敲一遍吧。

我自己是敲过一遍的，开始的十几节打印各种字符非常的枯燥，后面会稍微好一些。一边敲一遍看书上的解释，对以后学习其他语言都很有帮助。

另外书的最后几个例子里用到了单元测试，对测试同学来说应该是可遇不可求的相当完美的学习资料了。

step 2: 用语言去解决问题

测试同学平时用到python的机会可能不多，那么我们就需要自己创造机会去使用它。

今天正好看到一个项目挺有意思的，推荐给大家做练习使用。

项目地址: https://github.com/zhiwehu/Python-programming-exercises

这里面列举了100个可以用python编程去解决的问题，分为3个难度

Level 1 Beginner means someone who has just gone through an introductory Python course. He can solve some problems with 1 or 2 Python classes or functions. Normally, the answers could directly be found in the textbooks. 完全小白。
Level 2 Intermediate means someone who has just learned Python, but already has a relatively strong programming background from before. He should be able to solve problems which may involve 3 or 3 Python classes or functions. The answers cannot be directly be found in the textbooks. 有其他编程经验的python初学者。
Level 3 Advanced. He should use Python to solve more complex problem using more rich libraries functions and data structures and algorithms. He is supposed to solve the problem using several Python standard packages and advanced techniques. python进阶使用者。

下面这道题就是属于level 1完全小白难度的。

关于成长

Tue, 17 Jun 2025 17:29:15 +0800

2020年的春节，比以往时候来的更早一些。

不知不觉离过年就2个月了。

2019年似乎特别的短，上半年过完就期盼着国庆长期，国庆回来没几个月又是春节，在这匆匆忙忙的一年中，我们是不是有所成长呢？

从工作的角度上看，成长可以分为这样几个方面吧。

业务的成长

你负责的业务/产品跟去年相比是不是有成长呢？

比如一年前产品刚上线，一穷二白。现在产品在线上稳定运行了一年，各项运营指标都很不错，业务稳定增长。

又比如之前产品/项目风风火火，不料今年突生变数，原本数十人的团队现在只有几个人，裁的裁走的走，这是业务衰退的典型例子了。

业务有增长代表了有向上的空间，是有经验的测试同学所需要着重考虑的；对于经验尚浅的同学来说，业务增长代表了能接触到的东西变多，挑战尽管较大，但成长的速度也会相应快一点。

个人技能的成长

一般来说技能成长是一个重复的过程。

比如写代码，重复的次数多了自然就熟练了。

再比如linux命令，多敲几遍此然就记住了。

因为测试很多时间是一个重复的过程，所以一直重复一件事情，点来点去这个技能是可以得到增强的。不过如果只在一个地方点来点去，那么不仅无聊，而且得到的技能成长也是有限的。

所以除了重复之外，个人技能成长跟接触面有关系。接触的东西越多，或者对同一件事情有更深的挖掘，个人技能也是可以有不错的提升的。

深度和广度可以配合着来，相辅相成。

软技能的成长

沟通能力，表达能力之类的软技能对于测试同学来说也是挺重要的。

好的测试同学往往有不错的沟通能力和表达能力，在项目组中承担润滑剂的角色。

另外测试同学还需要有一定的分析问题和解决问题的能力，这些能力可以为我们的决策提供良好的支持。比如线上出了一个问题，是紧急停机发版本修复还只是修复错误数据继续提供服务？这些决策往往由测试同学给出会比较可信。

其他成长

比如薪资的增长，体重的增长，生活中角色的变化等等，工作只是生活的一部分，平衡好工作和生活，每个人都有自己的生活(生存)方式，知道自己想要什么，努力保持内心的平静，不盲目被鸡血，不轻易被洗脑，别人得到了很多的同时，大概也失去了不少，懂得了这些，也许就是人生中比较重要的成长吧。

原始封面

关于双十二崩盘的一些思考

Tue, 17 Jun 2025 17:29:15 +0800

双十二的时候我们的一个重要业务崩盘了。

原因其实很简单，就一句话，流量太大导致某个中间件接入层的HA proxy满载，中间件不可用，整个业务基本瘫痪。

从测试的角度去总结一下，大概以后可以有如下的改进。

技术方案评审时就考虑高并发问题

我们这次的事故是因为比较乐观，可能技术方案评审的时候就开始盲目乐观了。

其实流量增长的速度有可能是我们难以去精确预估的，所以技术架构设计的时候我们就要提前准备。

对于测试同学来说，大家可以简单记住下面一些要点。

降级。在大流量的情况下，是否能通过一些机制让服务降级，从而保护整个系统的稳定性。举个例子，可能一般情况下，用户购买商品下一个订单就可以马上看到订单的详情，但是在秒杀场景中，用户可能在下单很长时间之后才能看到订单，这就是一种服务降级的表现。
削峰。把流量的高峰削平，不让突如其来的大流量对系统产生破坏性的影响。举个例子，12306抢票的时间点是分散的，大概每个小时抢一次，这就防止了一次性放出所有票导致所有用户同时抢票带来的流量高峰，这是一种业务上的削峰。
限流。这个很好理解。一些第三方api会限制每分钟调用的次数就是这个道理。
熔断。高并发时,如果一些api无法访问后，能不能自动不去访问这些有故障的api，从而保证主流程的顺畅和稳定。
故障摘除。一些容器如果被击垮，能不能动态去摘除这些节点，从而保证整个系统可用。

了解架构

事故之前，我们其实对整个架构能支撑的容量做了计算，结论是在当前架构下是可以撑住双12的峰值的。但是千算万算却没想到中间件在接入层之前有HA做负载均衡。这个ha实际上是单点，容量有限，如果提前了解该架构，并且进行扩容的话，事故大概也不会发生。

测试同学在看架构的时候可以先无脑关注单点问题。某个服务或中间件是不是单点？如果是，那么单点挂掉之后对整个系统可用性会不会造成影响？搞清楚这个问题的答案对系统高可用非常关键。

提前做好紧急预案

问题总会有可能发生的，因此提前准备好预案非常重要。

这次事故发生之前，我们并没有准备应急预案，因此，当临时发现了无法动态扩容的HA单点时，我们基本上只能眼睁睁的看着系统挂掉，什么事情都做不了。

不要迷信动态扩容

动态扩容属于亡羊补牢，在问题发生时候的那几秒，扩容往往是无法迅速完成的，因此提前计算好容量才是关键。

最后，下次的活动是在明年的双十一，嗯，这个锅要背一年了。

惭愧，惭愧。

原始封面

过气测试网红的自我隔离14天

Tue, 17 Jun 2025 17:29:15 +0800

我是乙醇，一个过气了的测试网红。

那天早上我拿到了出入证明，一路向南，穿越江西广东，孤身一人直达深圳。

原本车流不息的高速那天门口罗雀，经常开上一个小时才能看到一台车。路边倒是能看到小憩的倦鸟和不知哪里上来的牛群。

整个世界好像只有我一台车，一个人。

我这是在哪？一路上都是这么不确信。

14个小时后顺利到达深圳，办理好个人申报就可以进小区了。

然后便是半夜清洗冰箱，修热水器，那时候我意识到，冰箱啊，其实我是恨你的。

第二天中午鼓起勇气，全副武装下楼大采购。买了一些酒精，水果，鸡蛋，牛奶，不带叶子的蔬菜，比如土豆番茄之类，一点点鸡肉，油盐酱醋。买面粉的时候发现几个超市的面粉全部被搬空了，后来找到一家粮油专卖店，拿了10斤，买了5袋限购的酵母，把酒精抵押在超市，借了台需要200块押金的推车，把食物一股脑的运送回去。

还车的时候拿回酒精，超市工作人员赞许的目光让我无比舒适，仿佛有了酒精便能高枕无忧延年益寿。

至此需要自我隔离14天才去上班了。

那这14天里，除了远程办公我还能做什么呢？

远程办公

首先大量的时间都被远程办公占用了，尽管不需要通勤，但远程办公的时候往往需要及时响应，后面渐渐变成了随时响应，所以整体的办公时间其实还是不少的。

另外远程办公也需要提升效率，好的协作工作可以带来事半功倍的效果。

养活自己

作为一个生活能力极端低下的中年留守儿童，这14天最大的挑战就是养活自己。

因为远程办公的关系，每天基本上没有多少时间来仔细做饭，所以必须用最少的时间来生产尽可能多的食物。

冰箱里有不少从老家带过来的咸肉和卤菜，做为热菜小能手的我来说，肉类问题应该是可以解决了。

有鸡蛋和番茄，而且处理起来比较迅速，可以番茄鸡蛋汤/西红柿炒鸡蛋/番茄鸡蛋面几种形态间自由切换，是不错的快手菜选择。

有土豆和四季豆，干煸土豆，干煸四季豆啥的，应该能吃。

有一些榨菜和鸡肉，可以做榨菜肉丝面吧。

最后就是亮出我面点王的身份了。作为面包机达人，我可以用面包机发面，然后随便切切就做成馒头，一次性多做些，蒸出来用保鲜袋装好放到冰箱里，可以吃很久。

因为需要多喝水增强抵抗力，我决定多吃稀饭，这样就等于是一边吃饭一边喝水，就不会总是忘记喝水了。早餐可以吃稀饭，晚上可以喝粥，看起来很合理的样子。

稍微计算了一下，粮食储备应该可以坚持14天不出门。

想办法丢垃圾

出门就意味着风险和损失口罩，所以要尽可能少的出门丢垃圾，先把垃圾收集起来整理好放到走道，隔几天夜深人静的时候再去丢掉，目前也只能这么办了。

练习口语

作为英文口语的困难户，这次孤身隔离其实是练习口语的最好时机，反正有时间就在家里唧唧歪歪，就算打扰到了邻居他也不会上门理论，不知道闭关14天之后我的哑巴英语是不是会进阶成结巴英语。加油加油。

锻炼

在电梯间里看到宣传画上说，希望大家不要出门，加强锻炼，于是问题就来了，不出门怎么锻炼？

首先是多喝水，水喝的多应该比有一颗向往锻炼的心更重要吧。

俯卧撑和仰卧起坐，不受场地的限制。

瑜伽。我练过一点阿斯汤伽，在家里可以练，顺便缓解颈椎病的困扰。

读书

之前攒的那些书终于有时间拿来出来翻一翻了。

最后

这样看来其实14天应该是忙碌且有挑战的。

宅下去不乱跑，吃饱睡好，等到出关的时候，大概就岁月静好了吧。

原始封面

好书推荐:使用测试驱动开发的方式学习go语言

Tue, 17 Jun 2025 17:29:15 +0800

首先这本书是免费的。

其次这本书是开源的。

如果你想学习go和TDD（测试驱动开发）的话，这本书是不错的选择。

就个人经历而言，学习go语言目前比较好的材料是https://gobyexample.com，通过例子学习go语言，事半功倍。

而这本使用测试驱动开发的方式学习go语言内容则更为立体，非常适合大家在学习go语言的同时也对测试驱动开发有一定的了解。

什么是测试驱动开发

概念很大，简单来说，测试驱动开发是一种精神，就是先写用例再写实现代码的精神。

测试驱动开发其实是这样工作的

先写单元测试用例，测一个不存在的功能或者函数
运行单元测试用例，如果失败，则修改实现，直到测试用例通过
添加更多的测试用例
重复步骤2,3并进行重构，直到所有的功能都测试用例并且用例都运行通过

书上的例子

通过书上的例子可以对上面的步骤有一个感性的认识。

比如实现一个加法的函数，我们可以先写测试用例去测试这个函数，这个函数的名字是Add(int,int)，这是步骤1

package integers

import "testing"

func TestAdder(t *testing.T) {
 sum := Add(2, 2)
 expected := 4

 if sum != expected {
 t.Errorf("expected '%d' but got '%d'", expected, sum)
 }
}

接着运行用例，此时自然是会失败，因为Add()函数我们并未实现。错误如下:

./adder_test.go:6:9: undefined: Add

接下来实现Add()函数，以便让用例可以通过，这里有个规则，就是不要过度实现。

只为测试的运行编写最少量的代码并检查失败测试的输出。

比如你会看到这样的我们的实现是这样的

package integers

func Add(x, y int) int {
 return 0
}

这可以让我们的代码编译通过，这样就可以看到到底是哪个用例出了什么问题了

adder_test.go:10: expected '4' but got '0'

下面编写足够的代码使其通过。

func Add(x, y int) int {
 return 4
}

呃！！！！你这是在开玩笑吗？这样可以吗？

记一个线上问题

Tue, 17 Jun 2025 17:29:15 +0800

正愁着这周的公众号写些什么的时候，线上就很应景的出现了问题。

问题很简单，我们的app上有广告位，广告位的落地链接是在后台配置的。今天我们测试同学发现线上的某个广告位链接点击之后无法展示。

经过排查，我们发现原来运营人员在配置广告位链接时候在链接后带上了一个肉眼不可见的字符\t。

原因找到之后处理起来就很容易了，只要要运营人员去掉后面的不可见特殊字符就好了。

这应该是大家很常见的一个特殊字符的测试场景，在设计基于输入框用例的时候基本上大家都会做类似的用例验证。不过大家在验证的时候大部分把精力放在肉眼可见的特殊字符上，最常见的就是url encoding的时候需要转义的一些特殊字符，比如^%$@之类，基本上就是键盘数字键上方那一些字符串。不过这样是不完备的了，一些特殊的转义字符，特别是肉眼觉察不到的转义字符也是需要考虑的。

其实用例验证是后验式的，如果在需求评审和开发的时候就注意到的话，那么就算是漏测，也是不会发生线上问题的了。

针对这个场景，我们在跟开发沟通设计的时候，应该是可以这样做的。

首先前端在发送创建广告位请求的时候就应该过滤掉url首位的空字符和换行符，比如\t\n
其次后端在持久化url的时候也要做一样的工作，去掉无效的空字符
最后app端(android/ios/h5/rn)在跳转url的时候也要过滤掉首尾的空字符

总结一下

前端要做校验
后端要做校验
客户端有时候不能盲目相信服务端

最后大家可以牢牢记住一句话：永远不要相信用户的输入

用户的输入永远的是不可控的，一定要对用户的输入做校验和过滤(前后端都要)，否则出线上问题或安全问题是迟早的事。

原始封面

简单的unittest runner: green

Tue, 17 Jun 2025 17:29:15 +0800

首先来个截图。

green是unittest 众多runner中功能比较丰富的一个。

官方的featrue介绍如下：

Clean - Low redundancy in output. Result statistics for each test is vertically aligned.
Colorful - Terminal output makes good use of color when the terminal supports it.
Fast - Tests run in independent processes. (One per processor by default. Does not play nicely with gevent)
Powerful - Multi-target + auto-discovery.
Traditional - Use the normal unittest classes and methods for your unit tests.
Descriptive - Multiple verbosity levels, from just dots to full docstring output.
Convenient - Bash-completion and ZSH-completion of options and test targets.
Thorough - Built-in integration with coverage.
Embedded - Can be run with a setup command without in-site installation.
Modern - Supports Python 3.5+. Additionally, PyPy is supported on a best-effort basis.
Portable - macOS, Linux, and BSDs are fully supported. Windows is supported on a best-effort basis.
Living - This project grows and changes. See the changelog

简单来说，green的一些优势有：

简单讨论ELK在测试中的使用场景

Tue, 17 Jun 2025 17:29:15 +0800

什么是ELK

在高复杂度的系统中，对于定位线上问题，日志非常重要。ELK(ElasticSearch+Logstash+Kibana)，可以使用说是目前最流行的日志平台构建方案，之所以深受开发者喜爱，主要是因为它解决了大规模系统的日志收集的各种痛点。

ELK(ElasticSearch+Logstash+Kibana)，主要包含三个组件：

ElasticSearch
Logstash
Kibana

ElasticSearch

ElasticSearch是一个开源的分布式的搜索引擎，它主要基于Apache Lucene。在整个ELK Stack中，ElasticSearch是最核心的组件，它存储数据，并且提供了许多灵活而实用的Rest API，所以，上层应用可以根据需要去查询数据，使用数据，分析数据。在日志平台中，所有的日志数据都存储到ElasticSearch中，借助其强大的搜索能力，可以很灵活的查询日志。

Logstash

Logstash主要用于收集数据，并将数据保存到ElasticSearch中。

Logstash有丰富插件，并且易于扩展，所以，可以使用Logstash收集到数据后，可以做很多处理，最终再将数据输出到ElasticSearch中。在日志平台中，它主要复杂采集应用的日志。

Kibana

Kibana主要负责读取ElasticSearch中的数据，并进行可视化展示。并且，它还自带Tool，可以方便调用ElasticSearch的Rest API。在日志平台中，我们通过Kibana查看日志。

使用ELK存储测试报告

测试报告是自动化测试中非常重要的一环，测试结果的清晰展示以及归档是大家需要日常处理的问题。

既有的经验里，我们可以通过定制一些测试模版输出一些特定格式的测试报告，比如html格式，然后保存到测试报告平台或者直接邮件发送。

上面的做法其实没什么不好，不过可能需要一些开发工作量。另外归档和搜索之类的功能需要一定的二次开发能力，对于测试同学来说有一定的挑战。

如果用例运行的非常频繁，那么高频次的出报告持久化以及多维度的搜索也是一件非常麻烦的事情。

我们可以用ELK来简单粗暴的解决上面的问题。将每次的测试结果落地到日志文件里，然后使用Logstash处理并持久化到ES，最终使用Kibana来搜索，全程工作量很小，而且复杂的搜索功能开箱即用，成本低廉稳定性好，大家有兴趣可以不妨尝试一下。

使用ES管理测试用例

如果测试用例比较多的话，我们可能需要从很多的维度去搜索测试用例。假设我们开发测试用例管理系统的话，实现这些进阶搜索其实是比较大的工作量。

我们可以将ES当作是存储引擎，把测试用例保存在ES里，ES有非常有好的RESTFUL API，使用这些API去检索数据，然后对结果进行一些可视化，就可以实现一个功能较为完备的用例管理系统了。

如果不想二次开发就得到一个穷人版功能复杂的用例管理系统的话，可以将用例持久化成日志，然后用ELK工具链处理，最后使用kibana来查看用例，这也未尝不可。

总之用ELK来做日志的处理和搜索是非常方便的，我们在测试过程中如果遇到有大量数据需要灵活搜索的场景都可以尝试一下ELK。

原始封面

练手挑战：5个闲时挑战的python项目

Tue, 17 Jun 2025 17:29:15 +0800

python的初学者们总是会为找不到练手的项目而发愁，这几天正好碰巧在某视频网站看到有人分享一些不错的练手项目，于是就在这里大言不惭的抛砖引玉一下。

web网站(使用flask/django)

这是一个非常基础或者说是经典的练手项目。

我们可以给自己简单设计一个网站，然后用python去实现它。

当然在目前的情况下，实现网站可能会分为前端页面和后端接口这两块内容，不过使用flask或者django的话，其实你可以服务端直出html，加上一些前端的css和js，你就可以实现一些功能相对简单但视觉相对美观大方的网页了。

这里强烈推荐大家使用flask去玩一下，如果想降低实现难度的话，可以先不实现持久化(数据库)，另外前端的css和js如果大家也没有时间从零开始写的话，推荐大家可以使用bootstrap等前端框架，这样就可以相对的将自己的精力放在python语言和后端逻辑层面。

当然，这个项目最有魅力的是，你不仅可以学习到一些基本的web开发技巧，只要你有时间，你甚至可以通过项目学习到一系列的后端中间件，比如

可以通过实现每日点赞数功能来玩一下redis
可以通过学习持久化来玩一下各种数据库，比如mysql等
可以通过实现异步发送邮件功能来玩一下消息队列

最后，如果你有兴趣的话，你还可以把网站部署到云服务器上，顺便可以学习到一些运维的经验。

是不是很有意思？

改进一些流行的算法

比如自己实现一个解数独的算法或者是寻找最短路径的算法。

视频的作者就自己现实了数独的解法，他首先实现了一个纯文本的解法，后来使用pygame实现了一个数独游戏，不仅可以正常玩耍，还可以一键解决数独，总之看上去是蛮有意思的。

另外视频作者还可视化实现了寻找最短路径的算法，就是把动态解决问题的过程都展示了出来，让人感到非常的信服，作者应该是用pygame来实现这种可视化的。

其实大家可以从最简单的排序开始，把排序过程用pygame可视化，由浅入深，应该会非常有意思的。

实现一个俄罗斯方块游戏

俄罗斯方块可以在任何时候让人欲罢不能。

实现一个俄罗斯方块游戏应该是很多人都曾经冒出过的念头，既然有这个想法，那就去实现吧。

网上有很多实现的思路，代码，最重要的是，有很多的静态资源，比如背景，各个方块的资源等，实现起来是困难不大的。

另外也可以实现一个贪吃蛇，即怀旧又可以自己玩一玩打发时间。

实现一个AL/ML项目

视频作者说自己在tensorflow上抄代码，反正网站上例子特别多，他就先抄完，然后跑起来，这样就开始自己的机器学习/AI的之旅。

当你把所有例子都抄完运行成功以后，你对机器学习也就入门了吧，这时候就可以实现自己的各种脑洞了。

micorcontrol编程

视频作者使用类似树莓派的microcontrol实现了会议室监控的功能，大概是通过代码控制摄像头做人脸识别，然后记录下来谁进了哪个会议室，看起来没啥用处，不过挺有意思的，也很有挑战，毕竟人脸识别也运用了ML的知识。

树莓派加传感器可以实现很多应用，比如我就听说过某大厂用树莓派加传感器实现了手机的温度功能以及弱网IP的功能。

树莓派本身不是很贵，有时间的同学可以去玩一下。

总结

总之，如果你能完成上述5个项目，那么你的python运用能力基本上就可以满足日常工作的需要了。

原始封面

萌新的软件入门教程

Tue, 17 Jun 2025 17:29:15 +0800

第一天: 求职篇
- 为什么要做软件测试？
- 今后的发展如何？
- 经济收益如何？
- 软件测试的要求是什么？
- 我是不是适合做软件测试？
- 招聘要求解读
第二天: 认识软件测试
- 软件测试到底是什么
- 软件测试的分类
- 手工测试还有没有前途
- 小白的质量控制思路
第三天: 软件测试流程
- 开发流程
- 分支管理及策略
- 发布之前要做什么
- 发布之后要做什么(监控)
第四天: 需求分析
- 需求从哪里来
- 需求说明书是什么
- 谁来整理需求
- 需求一定是合理的么
第五天: 测试用例
- 什么是测试用例
- 测试用例模版
- 测试用例评审
- 如何写出测不出bug的测试用例
- 测试用例与测试点
- 用脑图去实现测试用例
- 测试用例管理平台
- 测试用例的3A原则
- 测试用例的编写方法(等价类啊啥的)
第六天: 关于缺陷的种种
- 什么是缺陷
- 如何提缺陷
- 缺陷的生命周期
- 缺陷管理工具
- 缺陷与发布准出
- 线上缺陷
第七天: 测试环境
- 什么是测试环境
- 什么是生产环境
- 什么是类生产环境
- 测试环境与分支策略

原始封面

命令行里的postman? wuzz初体验

Tue, 17 Jun 2025 17:29:15 +0800

postman是我用的非常顺手的调试以及测试工具，界面简洁优雅，扩展性相对较强，平时使用频率还是很高的。

不过postman有的一个比较大的问题就是没办法在服务器端使用，而使用go实现的wuzz则弥补了这一遗憾。

wuzz是命令行里的http请求交互工具，我们可以很清晰的看到，wuzz可以进行

类似于postman的请求调试工作
可以修改请求参数以及headers
保存请求
兼容curl
支持搜索

该工具整体的操作逻辑也很简单

使用tab键切换区域
用上下键翻页
类似于bash的一些操作，比如ctrl+w修改word之类的

安装

首先安装go，版本是1.10以上，建议直接上1.15以上。

$ go get github.com/asciimoo/wuzz
$ "$GOPATH/bin/wuzz" --help

使用体验

稍微体验了一下，优势和不足如下

优点

可视化的操作
相对清晰的操作逻辑
确实有一些postman的意思了
可以保存请求
可以查看历史
响应里的中文可以正常显示

不足

在我的乞丐版云服务器上整体的操作还是有点卡的
不支持自动补全
安装其实有点点难度

总结

命令行调试操作确实是可用的
但对于简单的请求，我可能还是会选择httpie

原始封面

你好，学画流程图吗？用代码的那种

Tue, 17 Jun 2025 17:29:15 +0800

markdown现在的扩展性越来越强，也玩出了更多花样。

我们可以使用marp来实现用markdown写ppt的功能，最近我又发现了令一款好玩的工具。

那就是用markdown来画流程图/甘特图/类图/实体图/饼图/各种图的工具mermaid。

该项目在github上开源，地址是https://github.com/mermaid-js/mermaid。

基本使用

mermaid的使用场景有

作为一个js库在任何网页上使用，我们可以使用mermaid API来动态把markdown文本渲染成svg图片；
跟主流编辑器结合，在编辑器上实现一边写markdown代码一边实时预览的功能；
在gitlab等工具上实现使用markdown画流程图的功能；
跟主流的blog以及cms系统结合，实现用markdown画图的功能；
在命令行实现把markdown文本转换成svg图片的功能；
实现一个渲染server，通过请求发送markdown文本，然后server返回渲染好的图片
……还有更多场景就不列举了

这里我用的最多的场景是用vscode/atom来写markdown文本，然后实时预览流程图，最后把图直接截出来，保存或者到处贴，这样就能让我的大部分文档工作都使用同一个工具(vscode/atom)完成，这样就不需要安装各种工具了或者在各个工具之间反复横跳了。

另外纯文本也非常适合直接保存在代码库里，方便多端多机器同步以及协作。

具体的例子

流程图的例子

graph TD

A[双十一] -->|存了一年的钱| B(买点东西);
B --> C{买什么呢?}
C --> D(iphone 12)
C --> E(macbook 16寸)
C --> F(ipad 2020)
F --> G((买不起))
E --> G
D --> G

上面的流程图渲染出来是这个样子的，比较简单，不过也有一定的配置能力，适用于一些相对标准的场景

甘特图的例子

画甘特图一般都是要装第三方工具的，mermaid可以覆盖一部分的使用场景，有一些实用性

gantt
 title 项目计划
 dateFormat YYYY-MM-DD
 section 开发
 概要设计 :a1, 2020-11-01, 10d
 编码 :after a1 , 20d
 section 测试
 用例设计 :2020-11-01 , 30d
 功能测试 : 24d

具体效果如下。

你可能考虑不到系统架构上的异常

Tue, 17 Jun 2025 17:29:15 +0800

对于测试同学来说，设计及执行异常场景的用例是平时工作中非常重要的一部分，因为只关注正常流程的话，那么很多情况下隐藏的缺陷并不能被完全的发现。

很多同学经常在上线之后感到惴惴不安，心里很没底，哪怕上线之前测试的再充分，都会有这样的感觉。这是因为我们很难预见到线上系统会出现哪些我们所没有覆盖到的异常场景。

异常场景大致可以分为下面这几类吧

业务上的异常流程

比如正常的业务流程是用户先操作步骤1再操作步骤2，但是用户偏偏先做步骤2再做步骤1。因为测试同学在执行测试时，往往是对被测产品有一定的认识的。既然对被测有所了解，甚至大部分情况是非常了解，这样一来就会对被测产品的设计是有一定的认同感的，就会先入为主的认为用户一定会先做步骤1再做步骤2，这样就会忘记验证异常的场景，造成缺陷遗留到线上，产生了不太好的后果。

所以一些有经验的测试同学会站在用户的角度上去设计测试用例。因为用户的行为永远是千奇百怪的，所以有时候我们确实要设计一些逻辑上看上去不太合理的用例，设计这些用例时往往还会伴随着 “靠，竟然有这种操作”的惊叹，这种惊叹用例往往是很有价值的，能发现程序设计或者是产品设计上的漏洞。

永远不要相信用户的输入，永远不要认为用户的操作是感性合理有章可循的。抱着怀疑的态度去测试往往能产生意想不到的效果。

操作上的异常

这种异常可能会比较隐蔽。比如在电商系统生成订单的时候，用户连续点击了n次提交按钮，导致产生了n个订单，这显然是我们不想看到的结果。因为用户行为的随机性，有一些操作我们真的是很难想象到，我们只能尽量借助于monkey等方式进行一些混沌测试，毕竟猴子比用户更加的不可控。

架构上异常

很多测试同学不懂架构却要为架构背锅，这大概是不合理的吧。

在测试同学的能力模型里，业务能力的加点应该是最高的，技术能力和架构能力的技能点往往是少加甚至是不加的。如果你不需要为架构背锅，那么不了解架构应该没什么大问题，但如果线上问题的锅基本上就是你的锅，那么懂一点架构起码可以防身辟邪，多少是有用武之地的。

架构的异常场景是我们在设计用例的时候很难想象到的。因为你没办法想象一个在你的认知里根本不存在东西究竟是什么样子，这比叶公好龙和盲人摸象更加的虚无缥缈。如果你的意识里系统架构都不存在的话，那么你怎么知道架构在什么情况下会出现异常呢？

举个简单的缓存的例子，在我们的系统架构中，缓存是非常常见的中间件，一些需要频繁操作数据库去读写的数据我们可以放在缓存里以加速访问和存取速度。不过缓存天生有一些异常场景。

比如我们把一些数据放到缓存里，但是用户在访问系统的时候这部分数据可能用到的很少，大部分的用户请求可能还是直接读取数据库，造成数据库压力过大，系统整体性能很差甚至崩溃。这就是缓存命中率低的场景，这种场景我们比较难设计业务用例去覆盖，只能对其进行专项测试和优化。

另外系统在刚上线的时候缓存可能是空的，这就导致用户的请求全部击穿了缓存直接到了数据库，造成数据库崩溃，系统不可用。这就是缓存没有预热，或者是系统冷启动的问题，这种问题应该是常识，是不需要测试就能想到的，但前提是我们要对系统架构有一些了解才可以。

还有就是如果系统频繁对某个具体key值的缓存做读写，那么该key所在的缓存实例可能就会过载，造成整个缓存集群性能下降，这就是热点key的问题，也应该是不用测试就能想到并提前防范的。

不过缓存的过期时间和更新策略跟我们的业务相关性还是比较大的，是可以在设计的阶段就想好，然后在测试阶段去验证的。

从上面可以看出，如果你不知道系统架构里有缓存这样一个东西，那么万一哪天缓存出了问题造成了线上问题，那这个某名奇妙的锅很可能对你产生巨大的降维打击。领导一句你为什么没有测出来，你很可能连辩解的理由都解释不清楚。

综上，异常场景往往是我们测试的重点，业务异常和操作异常是大家可以想象到的，不过架构上的异常大家往往难以名状，出了问题却又有苦难言。所以多学一些架构知识应该是有好处的，有些问题其实可以提前防范和规避，不需要在上线之后惶惶不可终日的。不过这只是作者的一家之言了，因为水平有限，所以还请大家多多斧正。

原始封面

盘点2021年最值得学习的自动化测试框架

Tue, 17 Jun 2025 17:29:15 +0800

魔幻的2020年马上就要过去了，竟然有一点点猝不及防。

我们还是要向前看，戴着口罩继续前行，这里就简单盘点一下2021年最值得学习的自动化测试框架吧。

selenium

毫无疑问，selenium仍然是目前市面上最值得测试同学学习的ui自动化测试框架。

selenium拥有稳定的api，这意味着你每次的selenium版本升级都相当安全。

selenium官方支持java/python/ruby等主流语言，另外由于webdriver协议具有很强的扩展性，因此你几乎可以找到大部分主流语言的selenium binding，比如go/javascript等，这无疑使得selenium在真实项目中的应用变得相对容易。

selenium支持所有的主流浏览器，而且是官方支持，这使得selenium在做兼容性测试上有着天然的优势。

selenium拥有活跃的社区，稳定的核心开发者，广泛的使用人群，这使得你可以非常容易的找到各种文档，资料，教程以及解决你实际遇到问题的各种线索。有时候我们放弃使用一个框架往往是因为我们遇到问题以后尝试各种方法都无法解决，这点在selenium上可能不会成立。

selenium背后的webdriver协议基本上定义了各种ui自动化框架的开发规范，比如怎么开启session，如何定位元素和表示元素等等，这也孕育了一些流行的ui测试框架，比如appium等。

想象这样一种情形：你们公司需要将web的ui自动化测试跑起来，但是测试人员对自动化测试的了解非常有限，希望尽快开始动手尝试，头绪不多，选择却很多，这时候其实就可以无脑选择python+selenium，哪怕用例最终没办法稳定跑起来，但整个学习的过程都会让团队及公司收益。这就跟我们练习跑步一样，尽管最终不是人人都可以去跑马拉松，但练习的工程却能让我们的身体受益。

总之selenium对于测试同学来说是性价比最高的测试工具，并且除了测试，selenium在爬虫，自动化效率提升上面也有天然独特的优势。

推荐程度：🌟🌟🌟🌟🌟，五颗星。

puppeteer

selenium在无界面的浏览器领域一直表现的都很挣扎，比如多年前的headless模式在面对稍微复杂的js页面时就一筹莫展，puppeterr的出现正好弥补了这一遗憾。

关于puppteer我之前有过详细介绍，其实就是无界面的chrome浏览器，这里就不过多解释了，相对于有界面的浏览器，puppeteer有着独特的优势。

google官方出品，chrome团队维护，稳定性相对可以得到保证
相对简单高效的api，使用方便
没有界面，资源占用相对可控，并且可以在浏览器端运行，天生有着云浏览器的潜力和属性
用户众多，资料丰富，遇到一般问题都可以搜索解决；
js语言调用，前端开发者基本没有太大的学习成本
生态丰富

不过原生的pupetter在调试上相对于selenium就没有那么方便了，好在一些第三方扩展可以缓解这些问题。

peppeteer适合这样的场景：对web页面进行持续的性能统计，一些不需要很高效但却要行为真实的爬虫，以及简单持续以及稳定的自动化验证用例。

推荐程度：🌟🌟🌟🌟，四颗星，适合有高级需求的同学

appium

appium是移动端自动化测试的领导者，是webdriver协议瓜熟蒂落的产物，它的出现看起来在意料之外，但其实也在情理之中。如果你想在andorid/ios以及移动web上都使用同一套框架的话，appium大概是目前的最佳选择。

appium的设计思想来源于selenium，所以有着跟selenium相似的优势

支持多种语言
api简单而且接近selenium
相对活跃的社区以及使用者

如果你对移动端自动化一无所知而且需要快速开始进行自动化测试工作的化，那么闭着眼睛用appium就可以了。如果你对测试框架的性能以及其他方面有定制性的需求，那么你可能需要花更多的时间研究其他的框架。

推荐程度：🌟 🌟 🌟 🌟 四颗星

cypress

浅谈测试观

Tue, 17 Jun 2025 17:29:15 +0800

前几天看到一个关于测试的观点。

We are capable of creating software systems that we are not cable of fully understanding. Therefore we test. We test to help us think about the design of our creations. We test to confirm our beliefs about our creations. We test to challenge our beliefs about our creations.

大意是可以创造软件系统，但是我们可能不了解我们究竟创造了什么。

因此我们需要进行测试。

测试可以让思考我们的设计，让我们确定和挑战我们对系统的认知。

第一反应是有点虚，不过仔细想想却隐含着另一层次的思考。

那就是对于软件测试，我们的测试观是什么？

不出意外，朴素的测试观点应该有以下几种吧。

验证

这种观点认为：因为系统是我们设计并创造的，那么测试的目的应该就是验证设计和真实的产出是否真正的一致。

比如我们需要系统实现3个功能，那么测试的时候我们就要验证这三个功能的实现是否符合预期。

另外我们还需要反向的验证。我们要实现3个功能，那么正常情况下这3个功能是要没有问题的，那么除去正常情况，异常情况会更多更复杂，这些异常情况也是需要验证的。

有经验的测试人员/开发同学往往能想到，或者是感觉到异常可能出现的地方，或者是考虑到大家都难以想象的场景。

反向验证比正向更难，而且难很多。

验证的测试观大致是相信正向的场景需要完全验证，异常的场景能够考虑和验证的越全面越好。

从更大的方面去考虑，这种异常场景的验证很像是统计学上的抽样，如果需要样本越接近整体，那么采样的数量就要越多。所以没有目的的多点点有时候反而有很好的效果，chaos monkey测试就是基于这个原理，模拟猴子乱点从而发现一些意想不到的问题。不过通过人工方式去增加异常验证的规模会比较困难，类似于fuzz testing这样的测试工程学上的探索就显得非常重要了。

怀疑

怀疑的观点认为：系统肯定是有bug的，只是还没有发现而已。

稍微扩大化一点就是开发讲的我不全信，除非你能证明你说的是对的。产品的需求也不一定合理，除非你能说服我。

让面试驱动成长

Tue, 17 Jun 2025 17:29:15 +0800

最近据说整个行业都越来越卷了，竞争日益激烈，好的机会和岗位可能会出现僧多粥少的情况，也许是时候推自己一把做一些反内卷的事情了。

反内卷最简单的方式可能是提升自己，让自己上升一个台阶或者是给自己多一条赛道去做升维竞争或者是弯道超车的事情。

那么如何快速的提升自己呢？

也许可以是走出自己的舒适圈吧。不迷恋各项事务都能得心应手的沾沾自喜，走出自己熟悉的领域，探索更有挑战的事情。

不过道理谁都懂，做起来却没那么容易。

主动走出舒适圈最大的问题是没有动力，缺乏动力可能是因为在舒适圈不会频繁遭受社会的毒打。我记得当初我努力学习技术的契机就是开发同学说你们测试不懂技术，跟你们解释也没用，至今都清晰记得那鄙视的眼神。

那么怎么安全的去接受社会的毒打呢？不如去面试吧，可能你不需要更换工作，但面试确实会让你短期内找到自己不足的地方以及了解现在市场的主流需求。

下面的案例是最近发生的真实事件，据说面试官是阿里的p7，由于各种原因这是一次电话面试。

情景：

问：你的接口自动化和功能测试的工作日常比例是多少？答：20%

问：你是怎么写你的接口自动化的？答：我说，当一个版本发布完成后，才进行补充的接口自动化；当然我也知道“Swagger”可以提前测试接口；

问：那为什么不在开始时就直接接口呢？答：因为项目忙，经常没有时间写（说忙，我脸都红了）；虽然也知道接口在开始的时候，其实更为快速和方便。

问：既然更为方便，为什么不直接使用。（然后陷入死循环问我这个。。。）答：。。。。（还是没时间的理由）。。。

问：好了，你的接口怎么写用例呢，（之后问了涉及到了怎么写字段检查、类型，长度，）答：统一答（只是正常流程，并检查数据，），具体很仔细的没有涉及；（总之问的超级细，那些点，哪些场景，当时真的打开了新世界的大门）

最后给定义了，自动化薄弱我感觉说的确实没错。。

可以看到面试官的思路是：如果你要证明你做了些什么，那么就必须拿出足够多的细节，细节是魔鬼，是最难的部分。

至于为什么会死扣细节，大致的原因可能是防止一些面霸通过死记硬背或者道听途说的方式去蒙混过关。

因为做过必定是有思路，有细节，有过程，有结果的，所以我面试的时候喜欢就候选人简历上列出的技能项和具体项目进行较为深入的讨论，如果发现里面有细节模糊的地方，就可以作出大致的判断了。

所以结果应该是比较明显了，没有跟上面试官的节奏，评价自然不会特别高。

不过通过这次面试，候选人应该也会了解到一些有大厂高级别背景测试人的基本要求，也知道了人家对接口自动化的要求，总之呢，这一个电话其实不亏。后面可以在工作中根据别人给予的合理评价进行深入研究就好了。

总之越被虐越强大，别虐的越惨，向上的动力越强。

不过大家的时间都是有限的，所以在选择面试的时候可以注意下面一些事项

人往高处走，大家应该去挑战那些比现在要求更高的岗位。比如现在是测试工程师，可以考虑挑战高级测试工程师，不过前提是简历别人要看得上。我的经验的简历可以多列一些关键字，一般hr都是根据关键字去匹配的，比如学校，技能，所在行业之类；
挑战大厂。比如二线公司的同学可以去挑战一线公司的职位，只要是比自己现在的公司技术更加先进的公司就可以了；
善于提问。一般面试结束之后，我们都会给出一些时间让候选人提问，这时候如果你能精准的问出你想要了解的问题，比如你们的接口自动化一般是怎么做的？什么时候做，遇到和善的面试官基本上会在思路上给你进行点拨，很多时候这些点拨是让人收益无穷的。比如我们当年在面试自动化测试的时候了解到某公司的qtp自动化用的是编程式的定位方式，而不是传统的纯对象库方式，当时就醍醐灌顶，从而有了新的研究方向；
永远保持信心。有些拙劣的面试官可能会在面试过程中不自主的表现出鄙视或者其他负面信息，这时候直接忽略就好，毕竟他面试的是过去的你，以后的你很可能逆流而上让人士别三日当刮目想看；另外面试官不一定永远是对的，求同存异就好了；

以上希望对大家有所帮助。

原始封面

如何设计与数据上下文无关的接口测试用例

Tue, 17 Jun 2025 17:29:15 +0800

我们在做接口测试的时候很可能设计出这样与数据关联的测试用例。比如

def test_create_user(self):
 user = create_user(name="fred", age=29) # 调用创建用户的接口
 self.assertEqual(user['name'], 'fred')

def test_get_user(self):
 user = get_last_created_user() #调用获取最新注册用户的接口
 self.assertEqual(user['name'], 'fred')

这样的测试用例第一眼看上去是感受不出来问题的。

不过仔细想想，可能会存在下面的问题

test_create_user用例必须在test_get_user用例执行之前执行，否则test_get_user(self)用户是没有数据的，* test_get_user用例没办法单独执行
test_create_user用例执行一次之后，name: fred, age: 29就成了脏数据了，不删除的话之后test_get_user用例有很大概率每次都能执行成功

为了解决上面的问题，我们可以这样做

def test_create_user(self):
 user = create_user(name="fred", age=29) # 调用创建用户的接口
 delete_user(user['id']) # 调用删除接口，将创建的用户给删除掉
 self.assertEqual(user['name'], 'fred')

def test_get_user(self):
 user = create_user(name="fred", age=29) # 调用创建用户的接口
 user = get_last_created_user() #调用获取最新注册用户的接口
 delete_user(user['id']) # 调用删除接口，将创建的用户给删除掉
 self.assertEqual(user['name'], 'fred')

这样一来脏数据问题就解决了，不过用例里多了很多跟测试逻辑无关的代码。

顺便留一个问题给大家思考：为什么删除数据的代码要放在断言之前执行？

为了将数据处理代码跟测试逻辑分开来，下一步我们可以这样做，以sqlite3为例

import sqlite3

def setUp(self):
 conn = sqlite3.connect('example.db')
 c = conn.cursor()
 c.execute("delete * from users")
 c.execute("insert into users ......") # 插入一些存量数据，这样测试翻页之类的逻辑会容易点
 conn.commit()
 conn.close()

def test_create_user(self):
 user = create_user(name="fred", age=29) # 调用创建用户的接口
 self.assertEqual(user['name'], 'fred')

def test_get_user(self):
 user = create_user(name="fred", age=29) # 调用创建用户的接口
 user = get_last_created_user() #调用获取最新注册用户的接口
 self.assertEqual(user['name'], 'fred')

上面的例子里，setUp方法会在每个用例执行之前执行，所以就不需要每条用例都去清理数据了。

总结

上面的例子都是以unittest库为例，其他测试框架库原理是相同的
上面的例子是伪代码，不能直接执行
上面的例子里，每个用例执行之前都会插入一遍数据，如果数据量比较大，那么用例运行速度会变慢

原始封面

如何做测试妹子喜欢的程序员

Tue, 17 Jun 2025 17:29:15 +0800

前段时间有些小伙伴反馈某些开发同学对缺陷单不太重视，比如偶现的bug老是不改，或者直接没有任何评论就修改了缺陷的状态转回到测试同学的手里，这让测试小伙伴的一些工作能难开展，当然这些开发同学自然是不受测试妹子们的欢迎的了。

那么怎么做让测试妹子喜欢的程序员呢？

举一反三

比如测试同学提了个缺陷，开发同学在修改这个缺陷的同时能够举一反三，发现这个缺陷也许可能隐藏在的其他地方，顺便一起改了，这样能节约测试同学很多的时间，自然讨人喜欢。

不改一送一

跟上面的类似，有些开发同学喜欢改一个bug送一个bug，这样测试妹子们会很不安心，惶惶不可终日。所以优秀的开发同学改bug的时候不能改一个送好几个，不过这也侧面说明改bug没那么简单，需要通盘了解上下文和影响，不然改的bug越多，送的bug越多

把问题解释清楚

大部分情况下，测试妹子们都是很好学的，所以开发同学在改bug的时候最好能解释清楚这个bug是怎么产生的，如何修复的，如何验证这个问题一定是修复了的，以及修复该问题时会不会对其他的功能有所影响，相信以测试同学的理解能力这些情况他们都是可以搞清楚的，这样的开发同学自然是相当受欢迎的。

测试妹子们最不喜欢的就是开发同学悄无声息的改了问题就提测，测完了尽管问题确实是修复了的，但是心里总是觉得不安定，因为不知道开发同学究竟改了些什么，安全感总是缺失的。

不夹带私货

有些开发同学喜欢重构以后就马上发布，每次除了必要的需求之外还夹杂了很多的私货。大部分时候这些夹带的私货是不影响功能的，不过万一有问题了就是线上事故了。

一个让测试妹子喜欢的程序员应该是改了什么都会告诉测试同学，一起商量回归的范围，这样男女搭配才能干活不累。

真的自测

一般来说开发同学都会自测的，但有些同学自测可能只是流于形式，走走过场，测了跟没测一样。

好的开发同学都会反复自测，保证没啥问题了再去提给qa测试，主流程一次通过，不会因为冒烟不通过而被打回，这样你好我好大家都好，提升了效率，也降低了双方的工作量

长得帅

好吧，其实认真干活的开发同学都是很帅的。

大家觉得开发同学还有哪些特质是会收到测试妹子一致好评的呢？

原始封面

如何做程序员喜欢的测试妹子

Tue, 17 Jun 2025 17:29:15 +0800

上一篇写了【如何做测试妹子喜欢的程序员】，这一次胡诌一个姐妹篇【如何做程序员喜欢的测试妹子】。

能描述清楚bug的重现步骤

记得我之前写bug的时候，经常会收到一些不知道如何是好的bug。有一些我看不懂bug的标题，有一些看懂了标题又不知道怎么重现，非常苦恼。

一般遇到看不懂的bug我都是直接打回去或者是放到最后去修复，这时候就可能出现忽略bug优先级的情况，先改能看明白的好改的bug，最后改看不懂的难以修复的bug，把一些风险高的事情最后做，实际上风险其实是更大了的。

所以程序员喜欢的测试妹子应该是可以把问题的现象描述清楚(标题)，以及把重现步骤弄的通俗易懂。当然，这是有方法的。

一图胜千言。好的截图加上注释可以让开发同学一目了然，立即醒悟到哪里出了问题；
录屏胜描述。能把重现步骤录下来自然是极好的；
描述清楚相关的上下文。比如机型呀，系统版本，程序版本之类的；
selenium IDE。selenium ide现在尽管是不维护了，不过其当年设计的初衷就是让问题的重现变得方便。我们可以通过录制脚本的方式把bug的重现过程保存下来，然后将脚本发给开发，开发运行之后就可以实时看到重现步骤了。现在应该也有一些录制工具可以实现类似的事情吧；
面对面操作一遍。这是大招，适用于【我的机器上是好的呀】的情况，大型打脸现场；

尽早发现问题

问题发现的越早，解决成本就越低。

如果可以在需求和开发阶段就发现需求的缺陷那将是一件功德无量的事情。

开发同学最怕就是在上线之前忽然提一堆bug，节奏被打乱，修复的成本也高，项目的风险也是难以控制。

举一反三

开发改了一个地方，如果测试同学可以指出其他相关的地方也要进行修改的话，那么大家合作起来会顺利的多。

当然这是一件见仁见智的事情，如果开发可以自己意识到这一点，这也是没有问题的。

了解实现

能了解开发每天在做什么，以及一些功能是如何实现的妹子，大概率是善解人意的妹子了吧。

了解实现的好处就是，有些问题可以弄清楚其出现的原因到底是什么。

因为有时候开发同学会技术性甩锅，如果测试妹子了解了实现，那么有些锅就没办法大事化小小事化了了。

这样的测试妹子会帮助开发同学成长，长久看来是受欢迎的。

坚持底限

有问题就是有问题，不让有问题的版本/产品流出去其实对团队来说也是一种保护了。

呃，套用之前的一个烂梗就是，有这样坚持底限的测试妹子，这是项目团队的福报。

落落大方

如何做测试妹子喜欢的程序员？第一条就是有头发。好吧，这点其实挺难。

如何做程序员喜欢的测试妹子？落落大方就好了吧？是吧？

原始封面

使用curl创建简单的性能监控工具

Tue, 17 Jun 2025 17:29:15 +0800

cURL，全称Command Line URL viewer，是一种命令行工具，用来发送网络请求，然后得到和提取数据，显示在标准输出（stdout）。

我们可以使用curl来获取网页的源码，显示头信息，显示通讯过程等。

在做基于http的接口测试的时候，curl基本上可以完成postman所具备的大部分功能，如果你习惯于使用命令行，那么curl是一个非常有用且常用的工具。

CURL的基本使用

查看网页源码

curl www.itest.info

查看response的headers

curl -i www.itest.info

显示通讯过程

curl -v www.itest.info

常用参数

使用curl发送GET请求时有一些常用参数。

-o: output，将输出的结果重定向到一个文件
-s: slient, 不显示进度信息
-w: 展示多维度的统计信息

统计请求耗时

使用下面的这条curl命令可以统计出请求的耗时。

curl www.itest.info -o /dev/null -s -w "%{time_total}\n"

其中我们把输出丢弃了(重定向到/dev/null里)，并且不显示进度信息，只展示请求的总耗时。

工具化

基于curl的统计请求耗时的能力，我们可以写一个简单的工具调用curl，然后打印出该请求的耗时。

下面是我用python写的一个简单例子。

# curl_tool.py
import subprocess
import sys

url = sys.argv[-1]

def get_cost(url):
 cmd_list = ['curl', '-o', '/dev/null', '-s', '-w', '%{time_total}\n']
 cmd_list.append(url)
 out = subprocess.Popen(cmd_list, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 stdout, stderr = out.communicate()

 cost = float(stdout) * 1000
 return cost

print "%s %s\n" %(url, get_cost(url))

使用方式: 在命令行中运行

挑战超低成本的NAS

Tue, 17 Jun 2025 17:29:15 +0800

最近发现视频和照片渐渐多了起来，我的机器储存空间有限，每次用移动硬盘去拷贝备份其实蛮麻烦的，所以想到是不是要搭建一套家用的NAS。

那什么是NAS呢？

我百度了一下，NAS（Network Attached Storage：网络附属存储）按字面简单说就是连接在网络上，具备资料存储功能的装置，因此也称为“网络存储器”。它是一种专用数据存储服务器。它以数据为中心，将存储设备与服务器彻底分离，集中管理数据，从而释放带宽、提高性能、降低总拥有成本、保护投资。其成本远远低于使用服务器存储，而效率却远远高于后者。目前国际著名的NAS企业有Netapp、EMC、OUO等。

所以NAS是一个网络储存设备，在家里搭建NAS其实就是在家里搭建一个百度网盘。

心动不如行动，先看一下这一套弄下来要多少钱吧。

打开某东，找了一款相对便宜的nas设备，618的价格是1899，不带系统盘和存储盘。所以加上128G的系统盘和1块2T的3.5寸硬盘，大概要400多块，总的成本是2300多，这样看来还是比较贵的。

那么有没有比较便宜的选择呢？

我咨询了一下某资深的各种电脑设备折腾家，他告诉我他家里就有一台NAS，他的解决方案是一台台式机，装centos，接一个raid5阵列，然后各种系统(win/mac/linux/ios)都用samba去访问储存资源。这一番话让我醍醐灌顶，原来nas并不需要专用设备以及装专用系统，思路一打开，后面的解决方案就很容易确定了。

我先整理了一下我的需求，需求决定实现，所以要先捋清楚，我大概有下面几个需求。

存储。我有一些文件/图片/视频需要找个地方存起来，这是备份的需求，因为副本是每天都存在的，所以这是一个日常存储需求；
从各个设备上看照片。没事我会翻一下照片，这是低频需求；
看视频/电影。这个是低频需求，因为基本没啥时间看；
走线/组网简单。我家里走线非常困难，所以NAS要支持无线传输;

所以综合看来，我的需求其实简单而且要求不高，那么我的NAS实现其实只要满足下面几个点就好了

稳定。长期不关机，所以系统用linux最好，我有一台云服务器自从启动到现在就没有关机或者重启过，几年了，非常稳定；
有samba就够，samba基本上支持所有主流的操作系统，而且搭建非常简单，省时省力;
功耗低。因为要常年不关机，所以电费的支出应该越低越好；
支持无线，不走线的方案才不是老婆见打的方案；

所以最后我选择的是低功耗机器+linux+samba的方案。

硬件篇

有了方案，那么就要选择合适的硬件了。

折腾家向我推荐了一款机器，是个mini主机，用的是笔记本主板，带无线，没有风扇，全靠铝制机身散热，某宝看了报价，32G系统盘+4G内存+cpu赛扬N3150的配置大概是810块，尽管成本还是有点高，买来会给贫困的家庭雪上加霜，但想到3150的cpu功率只有4w，长期使用的话成本其实可控，而且没有风扇的噪音，咬牙买了吧。

机器大概长这个样子的。

正面面板4个USB3,2个USB2接口，双千兆网口，双HDMI接口，带无线网卡，小巧，跟家里的路由器差不多大，安静，毕竟没风扇，唯一的问题是机身整体散热，所以要放在通风的地方，不能藏起来让老婆不发现，但搭建低成本NAS本来就是一个挑战，挑战总是有代价的。

再去某东买了块2.5寸的2T硬盘，500块，稳稳的塞进小主机里，这样总价1300块，硬件方面就准备完毕了。

其实也考虑过带风扇的小机箱准系统解决方案，如果去某宝捡垃圾的话(就是买国外淘汰的洋垃圾)，联想准系统(只有机箱主板没有cpu内存硬盘)大概300多，加上cpu内存硬盘，可能总价1000之内是可以搞定的，不过捡垃圾毕竟有风险的，而且折腾起来也花时间，万一翻车点不亮就麻烦了，性价比太低，所以就没有考虑这个方案了。

软件篇

下面就是装系统了，ubuntu，我所欲也，centos，亦我所欲也;二者不可得兼，舍centos而取ubuntu掌者也。其实这两个大众化的分发版本随便装一个就好了，因为ubuntu的live ubs教程更多，所以我选择安装ubuntu的server版本，也就是没有UI界面的版本。

装机篇

我从ubuntu官网下了个服务器版本的iso，然后通过教程一步一步做了个装系统的u盘，大概晚上10点半左右的时候开始安装server版本，大概11点就装完了。

装完以后发现server版本并没有带无线网络的服务，所以需要上网去下载，然而我并不能查有线上网，所以死循环了，翻车了。

没办法，只能下载个desktop版本，也就是有UI的版本装上，这个版本是自带无线网卡服务的，安装过程中无线网就配置好了。不过desktop版本安装非常慢，折腾好之后，安装ssh服务，然后禁用ui界面，重启进入纯server模式，搞完已经是12点半了，太累了，明天再战。

第二天晚上花半小时装好samba，迫不及待的拷了一些文件测速，nas的写入速度大概是2m/s，比百度网盘快不了多少，分析了一下原因，可能是因为走的无线网络，丢包率高带宽有限，所以2m应该是极限速度了，完美翻车。

### 调优篇

2m的上传下载速度其实跟百度云是差不多了，不过按照其他人的说法，这个速度是有上升的空间的。

首先能想到的就是组网方式的调优，要想办法把nas用有线连接到路由器上面去，这个基本很难，但可以挑战一下。

翻出一条陈年的网线，战战兢兢的把路由器从弱电箱里搬出来放在桌子上，最后让nas跟它肩并肩，一根网线两相连，再来试试速度，果然4M/s，比之前提高了2倍。

后面就是samba的配置调优，这个不急，有时候再搞，4m的速度已经超过了百度云，家用凑合吧，不过桌子上现在摆了2尊神器，我提醒自己一定要做好老婆的情绪管理。

外网访问篇

出门在外如果想访问nas那怎么办呢？

其实我的路由器是有NAT功能的，只要有公网ip就可以连接了，不过运营商基本把nat的端口给封完了，所以在路由器上配置基本就没有用了。

同事告诉我一个神器，是某品牌的一个盒子，接上去就可以从外网打洞/vpn访问家里的网络了。

花98买了一台，傻瓜式接入和配置，现在手机上直接vpn回家里，访问mas上的小文件基本上没啥问题了。

不过这个盒子有自己的局限，只支持2台外网设备，外网下载速度最多才250k，每个月只有1g流量，也就是玩一下，保留了外网访问的能力而已。

总结

这次低成本nas+外网访问的挑战算是告一段落了。

总成本大概是1400元左右，花费了大概6个小时的时间。

总之组网加各种配置是挺有意思的，但是装机啥的因为没有啥技术含量，就显得挺无聊了。

简单总结一下，这套方案也就是能用够用，成本不算特别低，不过稳定性还不错，功耗也比较低，长期使用成本可控。

下次看看再折腾点啥，来点更有意思的挑战吧。

原始封面

微软内部资料告诉你:如何成为优秀的软件测试工程师(1)

Tue, 17 Jun 2025 17:29:15 +0800

坐我隔壁的同事之前在美国微软工作多年，这天他递给我一本打印的册子，应该是微软的内部资料，封面上写着：What makes a great software engineer? 如何成为优秀的软件工程师。想到测试工程师也是软件开发的一部分，这些经验应该是相通的，于是就翻了翻，看看有什么是值得借鉴的地方。

持续提升

持续提升是增加自我竞争力的最有效的方式。随着年龄的增长，我们的知识和技能应该也是逐渐增长的。

之前前端技术发展很快，新技术和概念层出不穷，当时就有人感叹，技术太多，学不动了。后面学不动了成了一个梗，大体是用来指代不愿意持续提升的技术人员。

如果持续想在技术路线上精进，那么学不动了这种心态是很危险的；其实就算以后你走的管理路线，持续学习也是必要的，新的思路技术以及理念层出不穷，哪怕细节没时间了解，那么大体的概念也是需要了解的。

自我提升应该是一种习惯，每天花一点时间，日积月累进步就会非常可观了。

那么什么会阻碍你自我提升呢？

心理上的拒绝。希望待在舒适区，不愿意主动改变；
实在是太忙了。曾经看过一个纪录片，说的是香港的富豪体验3天左右的最底层清洁工的生活。富豪在开始体验之前还很乐观，觉得凭借自己的商业头脑，应该可以想出办法改变命运，但最终富豪一天就放弃了，因为清早就起床，然后不停不息的忙着生存糊口，根本没有多余的精力去考虑其他的事情了。对于很多人来说，活着就已经让大家竭尽全力了。

老外特别喜欢谈论工作与家庭的平衡，在中国情况可能不太一样，我们可能需要平衡：工作，学习，以及家庭。

open-minded

开放的心态。

对于新鲜的信息不排斥，不拘泥于陈见，拥抱变化。

执行力，不纸上谈兵

有一些同学说的多做的少，比如专门喜欢讨论技术方案，但缺不真正动手去做。

对于测试同学来说，这种情况相对比较少，做业务测试的时候往往开发都差不多完成了，对着现有的功能去测基本不会出现纸上谈兵的情况。不过也许有些情况下在做自动化测试和性能测试的时候我们会把大部分时间花费在调研和预研阶段，从而出现执行力不足的情况，这是需要去避免的。

self-reliant

独立自主的完成任务，必要的沟通其实没有问题，但可以独立解决的问题和克服的困难还是要多靠自己。

Self-reflecting

自省。

多反思才会多进步。

坚持

我们经常会遇到难题，这些难题只有坚持不懈才能去解决，而解决这些难题的过程其实就是提升，这也是在工作中提升的关键。

好奇心

好奇心会让你尽可能多的了解信息，从而为你以后的判断和工作积累足够的数据量。

匠人精神

对自己的产品感到骄傲，并且乐于磨练自己的心境和技能。

Desires to turn ideas in to reality

渴望将想法变成现实，并在这一过程中感到享受。

Willing to go into unknown

愿意步入未知，敢于冒风险去全新的领域接受挑战。

热情

对工作有热情才会带来高效和生产力。

专注

专注会带来意想不到的收获。

测试同学应该不需要专注在点来点去上，我们应该专注于质量管理，盲点识别和精通业务。

高效

效率越高，你就越有额外的时间来提升自己。

与组织目标对齐

这个很好理解，比如我个人兴趣是做自动化，但是团队的目标是先把产品上线再说，那么开始还是以功能测试为主，等以后条件成熟了，团队的目标变成了维护稳定的产品时再做自动化也不迟。

数据驱动

数据驱动包含两点，首先是定指标，然后是看懂这些指标。

对于测试同学来说一些质量数据的量化和解读都是非常有意义的，甚至可能直接影响到晋升等活动。

如果你在工作中完全没有用到数据，那么是时候开始接触这个概念了。

今天就暂时分享到这里，后面还有很多点，来日方长，以后娓娓道来。

原始封面

我的2019

Tue, 17 Jun 2025 17:29:15 +0800

2019的关键字应该是忙吧。

今年比较忙，从年初的项目从0到1上线，到年中的一些波折，以及下半年的各种大促活动，忙是主旋律。

忙着招人，从去年年底到今年，大概应该参与了100多场面试了吧，一场面试平均1.5小时，总体看来花费的时间还是很可观的。

忙着稳定业务，业务是要大踏步往前走的。没有业务就没有生存的空间，精力主要是投在这里了。

忙着解决问题，问题总是突如其来又猝不及防，慢慢来，办法总会有的。

忙着拿新的业务，业务多一点，生存的空间也许就大一点。

忙于工作就难免疏于思考。年底了，是时候来总结一下。

well

这一年做的好的地方不多。大概有下面一些吧。

坚持分享。基本上每周都有一篇公众号推文，水平良莠不齐，有阅读数不超过800的硬核技术文，也碰巧出过爆文，嗯，如果大家积极评论，我还是很开心的；
持续学习。年纪大了才发现要学的地方非常多，继续查缺补漏，由于精力有限，不能再像年轻时那样面面俱到，只能抓住一个点尽可能的深入了；
团队成长。今年的部门的服务稳定性和高性能都有不错的进步，尽力而为，希望明年做的更好；
业务稳定。几个业务基本上都跑通顺了，而且有余力去承接更多挑战；

less

做的不足的地方太多了。

给测试同学的成长空间不够。今年测试团队主要聚焦在业务上了，但其他方面的成长显得不是很够，明年要给大家创造更好的环境才行；
一些领域缺乏管理。精力有限，有些地方的管理确实没有跟上；
技术精进不够。今年的技术成长是不明显的，需要检讨；
质量意识没有传导下去。有时候是自己干着急，这样不行；
待在舒适区。没有做更多有挑战的事情，在舒适区温水煮青蛙，这样不好；

建议

作为一个很老很老的测试人，在这里顺便给大家一些不成熟的建议吧。

持续成长。前几天看了一篇文章，上面说到某年纪偏大的测试同学在公司倒闭之后没办法找到工作，仔细品读了一下，文章的主人公并没有持续进步，因此年纪大没有成为优势，反而成了劣势，行业竞争很激烈，继续成长是立身之本了；
寻求挑战。多做一些有挑战的事情，这无非是另一种成长的方式了；
不要焦虑。很多文章不经意间贩卖焦虑，看看就好，焦虑并不能解决问题，只会带来脱发的困扰。你去贩卖你的星辰大海，我自内心春暖花开；
不要过分的忙。太忙了连焦虑的时间都没有，才是最需要焦虑的事情。对大部分测试同学来讲，过分忙碌很有可能意味着没有时间进步；

原始封面

希望这份大厂测试面试心经来的不算晚

Tue, 17 Jun 2025 17:29:15 +0800

最近一直的面试，所以感触会比较多一点。

回想这些年，面了几个大厂，基本上顺利拿到了offer，其中有经验也有教训，在这里给大家分享一下。

鹅厂

鹅厂应该是我第一个拿到offer的大厂。

那时候应该是2009或者是2010年左右，一晃十年了。当时我的情况是211本科相关专业毕业，三年工作经验。不过工作经验不是很亮眼，加入过一个现在很有名气但是当年却没什么认知度公司，不过基本上对后面的面试过程没有任何帮助。

面试的岗位是测试开发工程师，不过那时候的测开基本上的工作是写自动化测试用例，跟现在做工具或平台开发的测试开发工程师还是有差距的，要求不如现在的专业测开那么严格。

一面是技术面，问了啥不太记得了。不过两个面试官的外形却让我感到新奇，一位带着耳钉，另一位是男生长头发扎了个辫子，鹅厂开放的文化可见一斑，后来这两位成了我不错的朋友，至今还有联系。

依稀记得当时长发哥问了我一个问题：做自动化测试时页面上的元素如何进行管理会更加高效？我的答案是使用页面对象(page object)的方式，那时候page object其实才刚兴起，用的人很少，用qtp的我其实也没用过，只不过当时在国外的qtp论坛上看到过有人对page object进行过讨论和分析，不小心记了下来，面试的时候就蒙混过关了。后来长发哥告诉我就因为这个回答他对我的评价很高，觉得技术不错，可以通过。不过我当时只是纸上谈兵而已，并没有真正落地过po，现在想来确实是很惭愧。

二面是组长面，问了个问题，大概是问服务部署在深圳，如何确保在新疆和西藏的用户也能稳定快速的访问。说实话确实不知道，不过也稀里糊涂的过了。

三面是跨部门面试，应该是测试通道的面试。三面里又分为两轮。第一轮问了个开放性问题，给你一个一次性杯子，你应该怎么测试？不记得是怎么回答的了，反正应该答的不好，面试官连连摇头。第二轮是通道会长面试，问了啥完全没印象了，不过应该是挂了。

接下来是四面。后来我才知道因为是第三面测开通道挂了，所以临时将我放到测试通道去做三面。测试通道面试了一轮，是通道老大面的，问了我很多技术细节，我完全答不上来，但是我一直强调我可能现在不会，但我可以学，我觉得我肯定能学会的。当时面试官的眼神是悲天悯人的，反正自我感觉不好，但是一不小心又过了。

五面是部门经理面，完全不记得问了啥，只记得问的问题角度刁钻，但又十分合理，让人难以招架。

所以，鹅厂一共面了5轮，见到了7名面试官，面的问题难度比较大，特别是在技术通道那边问的非常详细，没有做过的建议直接承认，没必要强行回答。多年以后看来，我当年可以面试通过完全是运气好，硬实力还是差了一些。

不过现在据说鹅厂的面试已经没有跨部门通道面试了，要求可能会稍微低一点点。

最终拿到offer，定级T2.3。

经验

平时的技术积累可能在面试时发挥非常关键的作用
拥有不错教育的背景在面试大厂时可能会带来不错的运气
对测试来说，初级到中级这个阶段技术的广度其实很重要
表现出良好的潜力或者勤奋好学的精神可能会打动面试官

教训

技术要扎实，有实力才能随机应变
测试开发要以开发的标准来要求自己

动物园厂

动物园厂的面试基本上都是电话沟通的。具体发生时期可能在2016-2017年左右，岗位应该是测试开发专家。

第一面是电话面，聊了一下之前做过的东西，比如测试平台的开发，效率提升工具的开发，基本上是问之前的经验，因为这块我做的比较多，里面的细节基本都清楚，所以答的比较自如。期间还探讨了关于测试覆盖率的问题，比如增量覆盖率，代码覆盖率，行覆盖率和分支覆盖率之类，最后讨论了一下圈复杂度对单元测试复杂度的影响，整体的过程不像是面试，像是在交流。

二面是半夜，大概十点半以后，也是电话面试，对方可能是团队的负责人，基本上聊了一下对于效率提升的看法，然后了解了一下后面要负责的具体工作，持续了半个小时，基本上是交流的状态。

因为记忆已经模糊了，所以细节没有记起来太多。

总结：

动物园的电话面试一面聊了很多细节，比如之前做过什么，怎么做的之类，面试官有相同的经验，所以基本上靠忽悠是行不通的；
动物园的电话二面基本上属于在一面基础上进一步确定候选人的工作经历，与团队的匹配程度，不会再去讨论具体的细节问题；

最终拿到offer，定级p7+。

经验

大厂有时候的需求特别明确，如果能力与岗位要求匹配的话，整个面试流程会很轻松

教训

保持谦逊
自己的需求最好跟用人单位直接沟通，不要通过猎头，猎头的信息总是脱敏过的，毕竟利益不同

绿厂

绿厂的面试是现场面，应该是下午的时候去的，进去之前要做安全检查，当时很惊讶，毕竟除了菊花厂基本上没听说过会做安全检查的。

一面开始聊了一会之前的工作经验，面试官似乎对我无所适从，后来又拉了应该是他领导过来一起聊了一下，基本上技术层面的东西涉及的比较少，或者是因为他们涉及到的基于安卓的底层测试我没做过，所以就没有仔细问了。

二面应该是部门的测试负责人。主要是跟我介绍了一下绿厂的情况和遇到的问题，然后带我去食堂吃了个晚饭，晚饭挺便宜的，味道也在线。

三面是hr。hr问了很多问题，细节不记得了，主要是考察稳定性，比如有没有小孩，是不是在本地定居之类的。然后就是非常严肃的告诉我，绿厂的工作强度非常大，比如需要加班，周末有时候也很忙之类的，问我能不能接受。抱着收集offer的态度，我很肯定的回答了接受，hr面就顺利通过了。

四面是部门长面试，有2个人，一个可能是部门的技术专家，另一个是部门长。其中技术专家问我能不能尽可能详细的列出linux的性能参数，我应该是白板上密密麻麻的写满了从cpu到内存到磁盘io以及网络的性能指标，并描述了指标的含义和具体的异常场景，当时就感到两位的眼神中充满了惊奇和肯定，这一面顺利通过。

不出意外拿到了offer，定级不记得了，应该比较高。

经验

如果面试的时候遇到了自己拿手的领域，可以尽情的开始你的表演
如果面试时间持续的比较长，也许有机会蹭一顿饭
绿厂的工作强度比较大，我面试从下午一直到晚上10点，走的时候办公室里还高朋满座

菊花厂

大概是在2008年我就参加过菊花厂的面试，当时的岗位是测试工程师。

当时是在某个园区举行的专场。

一面在食堂做题，做完题以后现场等结果。

通过一面以后在食堂二面，不记得问了啥，大概意思是我们这里很忙，你确定可以接受吗？自然回答说接受。

然后就是叫号，叫到号的从食堂带走，分批进行群面。群面在工作区的会议室进行，进去前所有东西都要清空，手机也被严肃认真的保安暂时保管。

群面应该有3个面试官，可能是西装革履又可能是穿着比较复古，总之对他们的衣着印象深刻。

群面是各种岗位一起面试，在一起面的有市场销售有开发和测试，但是开发和测试的人很少很少，可能就1个测试和1个开发。可以明显感到销售的同学轻松自在谈笑风生，开发的小哥一脸嫌弃，而我应该是比较紧张，正襟危坐，战战兢兢。

群面的过程大概是先介绍自己，然后说自己的优点和不足的地方，等大家都介绍完以后面试官就开始带节奏，随便指定一人做靶子，再明示其他人群启而攻之。最后每个人都被轮一遍，群面胜利结束。也许当场就选出了群面的胜利者继续后面的流程，淘汰者黯然离开，细节记不太清楚了，流程大致如此。

这次面试耗时一整天，从早到晚，没有通过，不知道是为什么，反正也只是去见识见识，所以也不放在心上，只是群面的感受让人觉得奇怪，为什么一群人周末的大好时光不做点有意义的事情，反而聚在一起相濡以翔呢？

果然几年以后当我第二次面菊花厂时，群面的环节消失了。

一面的面试官是测试专家，问了一些测试思路和测试工具的问题，似乎没有细节，但是很广很杂，不是特别好回答。

二面是部门老大，不记得聊了什么了。

总之大概2个多小时就搞定了，变化的部分是没有了群面，不变的部分是依然在食堂。

顺利拿到offer，应该是专家级。

写到这里忽然想起在这之前也拿到过一个菊花厂的offer，不过定级就没这么高，所以印象就模糊了。

因此菊花厂的总战绩是3战2胜1负，面试不难，但整体的流程很长。

经验

菊花厂的面试相对灵活，但整体流程很长
菊花厂对身体要求很高，如果有半年的空档期，简历很可能是无法通过的，因为用人方可能会认为你休假半年去治病或者休养

BD厂

BD厂面了2次，第一次挂了，第2次通过。

想换工作简历怎么写面试要注意什么

Tue, 17 Jun 2025 17:29:15 +0800

这两天在学院群里，有同学问了一个非常有代表性的问题。

当前做的是功能，想跳槽做性能、自动化。简历，面试，都需要注意什么？？？

首先需要说明的是性能和自动化目前在一些公司是测试人员的标配技能了，去找这类的专项测试工作可能放出来的职位不会很多，可选择性没有那么强。所以我们可以这样来看这个问题，就是当前做的是纯功能(手工)测试，想跳槽做一些挑战(xin shui)高的工作，可能涉及到性能和自动化之类的，面试和简历需要注意些什么？

简历篇

除非你是刚毕业不久，或者工作经验少于一年，那么如果你面试的岗位是有自动化和性能的要求的话，最好写上相应的内容。

为什么呢？

因为第一个看你简历的人是hr，大部分的hr筛选简历的标准都是有章可循的，比如

教育背景。教育背景好的话，那么经验欠缺一些也是没问题的，毕竟好的教育背景在hr看来是值得去培养的，好的教育背景等于较好的潜力
技能关键字。比如jd里面要求了python/性能/自动化之类的，那么hr会优先去匹配这些关键字
名企背景。这个大家都懂，名企背景是个很好的背书。因为名企招聘的要求本身就不低，有名企背景的人就证明他的起点可靠度会更好
项目经验。比如招大数据的测试，hr会看你是不是做过大数据相关的项目。我就内推过一个同学然后被hr拒掉的，因为有技能关键字，但是项目里体现不出来技能关键字，这样就被判断为不合适了

所以，总结一下，简历可以这样写了。

教育背景好可以强调一下，比如学校名称后面加个211，985之类的，前提是，实事求是，不要弄虚作假
技能关键字跟着jd走
项目经验跟技能关键字最好能对应上

当然了，这个是个人观点，仅供参考。

面试篇

面经到处都是，我这里专注一种情况，也就是没有在项目里做过自动化和性能的情况下，如何在面试时候让人觉得你可以胜任此类的工作?

首先我不是教你弄虚作假，面试官都是很有经验的，弄虚作假没有意义。我这里只是抛出一些问题让大家提前思考，这样面试时候也可以坦诚的聊一下，把自己提前思考的答案跟面试官交流一下，说不定能有共鸣。

首先考虑细节，比如

你们的接口测试里面有没有做鉴权？鉴权的细节能不能说明一下呢？
你们的接口是说明协议的呀？能说明一个这个协议么？

很多情况下不知道细节等于没有做过。比如如果你回答，我们有鉴权呀，鉴权就是调用开发的接口呀，细节我也不清楚，那么面试官可能认为你技术深度不够或者是没有做过。

细节是最难的，因为你的任何技能关键字都有被问到细节的可能。而且可能你的弱项是面试官的强项，然后被强行拖入面试官熟悉的领域，按在地上摩擦。

然后就是场景了。比如

你们在什么样的场景下做自动化测试呀？
你们的接口测试是怎么样的执行策略呀？
你们性能测试的场景是什么样的呀？

自动化测试的场景其实很多，比如定期的回归，线上用户侧监控之类的，都是自动化的场景。而有一些场景是不合适的，比如快速迭代的新业务就不是非常适合，你的答案最好逻辑上能自洽，不然很容易被面试官挑战。

接口测试执行策略可以看出你的测试工程化的思维。比如接口测试的执行频率，执行环境，测试环境的规划，测试数据的规划，这些我在之前的文章也多多少少涉及到一些，大家可以参考一下。

总之，你的性能/自动化/接口等测试一定是有场景的，可以落地的，否则很容易被一直挑战。

流程也需要考虑。

你们自动化测试的流程是？
你们接口测试的流程是？
你们性能测试的流程是？

这里的流程又关系到用例的编写思路，回归策略等。需要注意的是，性能测试一般是功能测试结束之后，这点不要弄错了。

所以，总结一下，如果你没做过性能/自动化/接口等专项测试，你又想跟面试官来电，那么你需要考虑

将场景代入现在的项目。哪怕你没有真的做的，你也可以想象一下如果是自己来做，你该怎么做。自己的项目里哪些地方可以用到专项，用的时候会遇到什么困难等等，注意逻辑自洽
脑补流程。你的专项测试流程是怎么样的，什么时候介入，什么时候结束，结束的时候有什么产出等等
技术扎实。尽量在有广度的前提下，深入一些细节，最好是你技术关键字的一些细节。比如selenium的原理，appium原理，webdriver协议之类的

上面就是我的一些不成熟的建议，还请各位不吝斧正。

原始封面

一起读测试论文(1)--web自动化测试工具

Tue, 17 Jun 2025 17:29:15 +0800

最近看到了一篇2014年的论文，在google scholar上面排名比较靠前，随便浏览了一下，内容非常的平易近人，可以给大家分享一下。

在介绍部分，文章说道，软件测试是软件研发流程中的重要一环，占到整体时间周期的40%-70%，软件测试的目的是

确定软件符合需求
准确实现了特性
满足金主的预期和需求

总之一句话，软件测试很重要。

下面文章又介绍了测试的类型

静态测试和动态测试
box approach方法，应该是灰盒测试
手工和自动化测试

下面是手工和自动化测试的比较

执行速度上：手工慢，自动化快
人力资源投入上：手工要投人测，自动化不需要
隐藏信息上：自动化可以拿到隐藏信息，手工不行，这条我也不是很理解
可靠性上：自动化测试每次执行的结果都很精确，手工测试同样用例每次执行结果可能不一样

测试工具的进化史

这是比较有意思的部分了。下面的文字属于机翻，可能语义上没那么准确。

软件测试其实并不是什么新鲜事，在40年代用于测试软件的程序员中，他们不仅是测试人员，也是开发调试人员在整个六十年代，有关测试，例如IFIPS会议的议事录，几乎假设程序员已经测试了他们所使用的软件。随着更大，更复杂的系统的出现，专门的软件测试人员开始流行。第一次测试软件会议于1972年在教堂山组织会议记录表明测试的学科不同于编程。技术的自动化使我们可以共享信息，几位研究人员使用了Web自动化研究工作中的测试工具。研究人员还增强了一些工具，以获得更好的性能和结果。这些工具可以独立应用，也可以组合使用，来解决软件测试中的挑战。在这里，我们讨论使用以下工具完成网络自动化测试的工作。

Leott等提出了关于测试的工业案例研究学习环境中的自动化和测试套件维护的内容管理系统。在此作者提出调整工作，得出基于ID的方法定位比Xpath更好的网页元素方法。作者工作的目的是了解哪个Selenium WebDriver方法适合于定位Web页面元素，减少了所需的维护工作将测试用例重新调整为新版本。 Leott等还提出了另一项关于工业的报告进行案例研究以调查潜在利益页面对象模式的改进，提高selenium webDriver测试用例的可维护性。论文比较了两个等效的测试套件。其中一个是使用页面对象模式，另一个并则没有。结果表明使用PO对象的对照组可维护性胜出。

Cheluvaraju等提出了一种新颖的方法，调查文件之间的关系通过应用高级SNA共同致力于社交网络分析。在本文中，他们对修订版本的历史进行了实证分析。众所周知的开源Web应用程序测试系统， selenium和结果参数，例如提取交叉语言更改依赖性，更改传播，影响分析报告。这段原文我也看不懂，机翻的也是一头雾水。

Wong等提出了一种采矿的方法，给定的Selenium IDE测试套件中的可执行规范。那里的方法通过测试套件的数量进行评估现实世界。那里的工作还展示了模型挖掘和模型的两个相反过程,基于一个框架的测试生成。 Nagowah等通过分析现有的工具，提出了一种自动化的设计的测试工具Kishanium， Kishanium工具是一种创新工具，改进了记录和回放方法。工具管理套装测试数据，并且即使存在是用户界面中的更改数量。工具提供其他功能，例如数据生成器，spylink, 快照。

Wang等引入了新的自动化框架由selenium和Jmeter集成。该框架大量复用了测试步骤和测试数据，因而很容易跨应用迁移，支持多浏览器和操作系统，大大提升了自动用例的扩展性和重用性。

这部分其实给我们介绍了一些研究人员在自动化框架上的探索实践，可以补充一下我们的技术视野。

最后一部分就是各种自动化测试工具的对比了，很多工具因为年份久远，现在市面上基本上都见不到了，只剩下selenium QTP等老牌工具依然不忘初心，持久坚守。

所以大家可以看出来，对于自动化框架的探索，这些年其实并没有特别突破性的技术诞生，很多6年前论文中提到的东西，我们还在孜孜不倦的反复实现。

不过技术的洪流总是滚滚向前的，在AI时代即将到来的今天，自动化工具和框架也许会迎来井喷也说不定，我们继续努力，持续学习。

原始封面

一起读测试论文(2)--基于selenium+testNG的测试框架

Tue, 17 Jun 2025 17:29:15 +0800

今天给大家带来的论文发表于2015年，全文的主旨是在描述如何使用selenium + testNG来实现一个稳定高效的web自动化测试框架。

文章开篇还是祖传的测试论文三件套

为什么要做测试
什么是web自动化测试
用什么工具做web自动化测试

这里就不展开了。

后面直接上了一张模块图，并对每个模块进行了详细的说明。

Object Repository

对象库。好吧，你说你没有对象…

selenium支持多种定位业务元素的方式，不过如果页面频繁变化的话，用selenium原生的地方方式就会带来一个维护成本偏高的问题。

于是有人就提出了对象库的概念，把所有的元素定位都集中在一个地方管理，我最早是在08年左右在一个叫做QPT的自动化测试工具中了解到这个概念的，如今12年过去了，这种方式依然行之有效。

Input file

在web系统中，用户经常需要输入一些信息，比如登录时候的用户名和密码。这些输入就可以放在input file里维护，这样每次输入相同内容的时候就可以直接从文件里读取了。不过要注意的是，这里仅维护一些必填项，一些可选项我们可以用随机值的方式去代替。

Utility Section

工具库，可以分成下面几种。

User Actions File：selenium提供了一些基本的元素操作方式，比如点击，但是另外一些操作，比如选择select box等的复杂操作其实并没有提供(原文大概是这个意思，不过selenium后面的版本确实提供了多种多样的操作行为工具，比如action chains以及select的操作等，可能当年文章写作时selenium是缺乏该能力的)，可以将这些操作封装起来，后面调用的时候就可以多次复用了。
Utility file：这个文件封装了一些常用功能，比如登录登出。
Screenshot Generation：实现了用例错误时自动截图的功能。

具体截图过程如下

创建文件夹
从testNG拿执行结果
判断执行结果
如果执行失败则自动截图
截图用执行时间来命名
保存截图

Test suite

testNG提供。

Customization of test report

自定义测试报告。基本上就是用的testNG提供的html report。

Email customized report to respective person

发邮件通知相关人员。使用 Mail.jar来实现。

结果对比

文中最后给出了该框架prowork Framework对比传统方式的优势，基本上是全面碾压。

总结

可以看出框架整体的结构是非常简单的，核心思想就是尽量复用TestNG的功能，然后封装一些工具函数，增加框架的可维护性。

如果大家遇到一些技术瓶颈或是想了解最新的一些测试思潮，偶然读一些论文还是很有帮助的。

原始封面

一站式接口管理及测试工具yapi介绍

Tue, 17 Jun 2025 17:29:15 +0800

我们部门正在使用yapi做接口文档的管理，较之之前纯手工写接口注释的方式确实方便了不少。

功能介绍

稍微看了一下，发现yapi除了做接口文档的可视化管理之外，还有不少的功能。

按照官方说法，YApi 是一个可本地部署的、打通前后端及QA的、可视化的接口管理平台。

YApi 是高效、易用、功能强大的 api 管理平台，旨在为开发、产品、测试人员提供更优雅的接口管理服务。可以帮助开发者轻松创建、发布、维护 API，YApi 还为用户提供了优秀的交互体验，开发人员只需利用平台提供的接口数据写入工具以及简单的点击操作就可以实现接口的管理。

基于 Json5 和 Mockjs 定义接口返回数据的结构和文档，效率提升多倍
扁平化权限设计，即保证了大型企业级项目的管理，又保证了易用性
类似 postman 的接口调试
自动化测试, 支持对 Response 断言
MockServer 除支持普通的随机 mock 外，还增加了 Mock 期望功能，根据设置的请求过滤规则，返回期望数据
支持 postman, har, swagger 数据导入
免费开源，内网部署，信息再也不怕泄露了

亮点是支持类似于postman的接口调试方式，这对测试同学会比较友好；另外还支持自动化测试，支持response的断言。

自动化测试

那么yapi如何做自动化测试的呢？

yapi定义了包含测试集、Pre-Script 、Test-Script 三方面。

测试集: 在平时的开发过程中，经常遇到的一个问题是每次调试接口都需要重新填写参数，YApi测试集能够保存之前填写的参数，方便下次的调试。每个的请求参数还可以通过前面已请求的接口数据读取，或填写mock随机字符串，通过设置断言脚本验证返回数据的正确性。
Pre-Script:Pre-Script 包括请求参数处理脚本和响应数据处理脚本两部分。通过自定义 js 脚本方式改变请求的参数和返回的 response 数据。他的使用场景如下： (1)接口请求参数需要加密及返回 response 解密;(2)接口请求参数需要添加计算 token
Test-Script (测试脚本): 通过自定义脚本断言接口参数或返回 response 数据，在接口用例页面点击 Test 编辑。

具体示例：

assert.equal(body.errcode, 0)
assert.equal(body.data.group_name, 'testGroup')
assert.equal(status, 200)

总的来看跟postman支持的测试能力差不多。

插件

yapi支持如下的一些插件

疫情过后测试人员对面的机遇和挑战

Tue, 17 Jun 2025 17:29:15 +0800

最近在某视频网站看到有人讨论疫情之后有潜力爆发的一些行业，深以为然，结合自己对测试行业的浅薄理解，这里也分析一下疫情之后测试同学会面对的机遇和挑战。

可以比较确定的是5g 行业由于时机和国家政策的强力支持，将迎来爆发期。5g 行业整体产业链较长，所以会提供相当多的就业机会，毕竟有开发的地方就有测试，相爱相杀，喜迎福报。另外5g 的出现将催生一批新的行业，比如4g 带来的全民短视频现象，另外一些现有的产品也会产生新的形态，新产业的诞生和老行业的升级都是机遇。

宅家产业在疫情期间得到了一波流量红利，比如线上教育，在线幼教，在线带娃，线上会议等。这些产品形态在疫情结束后也应该会有迅猛的发展，毕竟如果证明效果拔群的话，以后线上的相应的行为是会减少的，特别是在线教育，前景是值得期待的。测试同学在找工作的时候可以考虑相应的细分市场和产品。这些产品将是以资本追捧的对象，换句话说就是可能不差钱，对应的待遇也有想象的空间。

送货到家，比如送菜送药等细分市场也在疫情期间野蛮生产，这种小而美的小店模式应该是疫情之后的重点发展方向。这种更紧密的线上线下结合产品对测试同学来说是有不少的进场机会的。这些产品往往意味着五脏俱全的客户端和庞大的上下游供应链后端系统，应该能提供不少岗位需求。

上面讲的是行业需求，下面我们不妨看看疫情过后对测试同学自身的要求是否会发生变化。

协作工作的使用能力。远程办公让人们意识到协作工具可以有效的降低大家的沟通成本，而测试很多时候都会充当润滑剂和主动沟通者的角色，因此更好的使用协作工具应该是顺理成章的必然要求。这些协作工具的使用包括但不限于：提让人秒懂的bug；提的bug可以带上自动化的重复步骤等等。总之从流程管理工具，到缺陷管理工具再到知识沉淀工具，从会用到用的精妙，是一个不算强人所难的要求。

流程的线上化。疫情过后流程的线上化，特别是测试流程的线上化可能会是大家所关注的点。因为线上化意味着更加精确的介入和控制，以及更加完善记录和总结，这会降低沟通成本，把流程的参与人员拉到同一个维度去进行思考和对话，进一步降低沟通效率。测试流程的电子化建设也会给测试同学带来新的挑战。

资源的线上共享。在疫情期间我们遇到一个问题，测试机在公司，而我们在家中办公，鞭长莫及。而且测试机现在挂在人身上，共享和远程获取都不是很方便，疫情放大了这个痛点，结束之后云测平台等各种个性化的解决方案可能会迎来新的春天。

有带测试玩的CI/CD。不管你人在哪里，ci/cd总在那里。之前有些公司的ci/cd其实是没有太多测试元素的，疫情期间测试远程导致测试效率降低之后，带有测试元素的ci/cd可能会是人们思考的方向。比如加入更多的自动化测试，加入门槛用例，加入适量的回归用例，这种ci/cd才能经得起远程和疫情的考验。

更好的沟通能力。如何不说话就把问题描述清楚，这是一门艺术，对于大部分行业都会适用。

代码能力。疫情过后远程资源的使用应该会越来越多，使用代码进行远程资源的调用和管理将是测试同学的必备技能了吧。

暂时想到这么多，尚待补充的地方欢迎讨论。

原始封面

用ipad做笔记是什么样的一种体验

Tue, 17 Jun 2025 17:29:15 +0800

今天分享的题目很知乎体，那就是用ipad做笔记是什么样的一种体验？

事情是这样的了，之前我在pdd上面蹲到了一张优惠券，差不多1900左右入了一个ipad mini5的乞丐版。A12处理器，64G的配置用来爱奇艺也应该够了吧。

因为新版的ipad支持手写笔，之前经常在本子上写写画画，不过各种本子整理起来其实蛮麻烦的，于是就考虑入一只手写笔拿ipad做笔记。

那么问题就来了，入什么笔比较好呢？

首选肯定是官方的ipencil，不过一代的苹果笔要500多，算下来基本上就是ipad机身价的25%，这年头钱还是很难赚的，加上如果之后新鲜了一阵就送去吃灰，500多的试错成本还是比较高的。

于是就在京东上选了个100多第三方笔，各种优惠券叠加以及京豆抵扣，大概100块就搞定了，试错成本直线下降，以后就算不想用了出掉也亏不了多少，所以就它了。

第三方笔的感受

首先我没用过苹果的官方笔，所以没办法做对比，但我入的高仿笔整体来说

写起来很流畅，也很跟手，基本上是指哪打哪，作为一只做笔记的笔，那是绰绰有余的；
待机能力感人，typec的充电口，充一次电能用很久，具体多久没算过，反正一直有电的状态；
typec的充电口，好评；
点触一下笔头就开机，我一般是拿笔头戳脸开机，灵敏还能提神；
防误触似乎做的不是特别好，有时候手放上去就直接zoom in了，肯跟官方的会好很多
能磁吸，不过ipad mini5不支持吸附，没啥用；

总的来说满意，考虑到价格因素，妥妥的80分，少给10分是祖传的防止骄傲措施。

笔记软件

ios自带的备忘录功能是支持手写笔的，不过据说比不上更专业的good note和notability，所以就二选一好了。

最终选了notability，其实没啥偏好和具体比较，就是随机选的。

记笔记

笔记软件上手还是有一些学习成本的，跟传统的提笔就记比起来，笔记软件的选择很多

可以调钢笔，画笔之类的，还可以选择颜色和笔尖的大小，可以配置的项目很多，选择多就意味着记笔记之前就要想一想，有时候想好了却忘了该记录什么了，双刃剑吧
可以选择画布和背景之类，我直接设置了一个默认值，省的每次都去选
有记录模式和浏览模式，不过记录模式下用手指滑来滑去其实就是浏览模式，所以按默认来就好

记录笔记的方式可选性也有

可以在pdf/ppt上画来画去，不过先要导入文件，试过一次就放弃
直接空白的纸上写，我一般用这个

效率

港真，我打字速度比较快，用笔写字不仅相对较慢而且丑，在记录一些纯文本的信息的时候，写字是的确不如敲键盘那么灵便的。

但是写写画画确实有他特殊的优势。

比如，画流程图。在电脑上画流程图其实并不是特别高效的事情，首先需要打开专门的画图软件，然后各种拖拽，键盘鼠标的操作一个都不能少。但是手写就不一样了，各种形状想怎么画就怎么画，流程图的布局以及标注都非常的灵活，架构图也是同理，这给了我们极大的创作和发挥空间。

另外在文档上进行标注和高亮用笔来做其实是相当自然的，有一种回到小时候读书时的感觉，相较而言使用鼠标键盘就是另外一回事了。

因此效率主要看场景，在一些需要创作空间的场景，用笔来做确实比较高效。

其他

ipad mini的屏幕尺寸比较小，其实用笔来各种涂鸦的画限制还是有一些的，而全尺寸甚至是大尺寸的ipad以及ipad pro应该是更好的选择。

不过考虑到便携性，比如ipad mini在地铁上拿出来其实不算突兀，而10寸以上的ipad在地铁上发挥空间就有限了。

总之

ipad上做笔记是有一定的实用性的，不怕写错而且修改起来相当容易，有笔记需求的同学可以试试。

最后这是我的统计学笔记的截图，献丑献丑。

原始封面

有人财务自由了，他竟然说要自动化

Tue, 17 Jun 2025 17:29:15 +0800

前不久看到一篇文章，大意是有个35岁的程序员实现了财务自由，然后选择退休。

稍微仔细看了一下，这个名为史蒂夫/阿德科克的程序员其实并不是真正意义上的财务自由，而只是财务独立，毕竟他退休的时候活期账户上只有百万美元的存款，更准确的意义上，他实现了财务独立。

他在一篇文章中提及了他认为每个人都应该掌握和坚守的6条财务守则。

第一，把财务自由当作首要目标
第二，积极扩展提升个人收入
第三，投资可以增值的资产
第四，凡事尽可能实现自动化
第五，清楚了解自己金钱的去向
第六，不买不需要的东西

这里面第1和第2没啥好说的，第5和第6是最难的，毕竟双十一要到了，尾款人大概率会买不需要的东西。

最值得说道的是第4点，如果这点是由一个亿万富翁说出来，我肯定认为他只是在吹牛而已，不过这话从一个程序员嘴里说出来，那么我们就要好好思考了。

为什么要尽可能的实现自动化？

个人认为可能有以下几个原因

节约时间

重复的工作从长期看来是最浪费时间的，比如每周从一些表格里拷贝一些数据手工进行汇总，手工统计bug缺陷率之类的，这些重复性的工作并不能让你变得更加优秀，相反只会浪费你的生命。时间就是金钱是老生常谈了，对于大部分的打工人来说，我们是靠出卖自己的自由时间来换得报酬的，那么把重复的事情自动化起来，我们就可以把这部分出卖的时间节约出来变成自己的时间，这样单位时间的收入其实就变高了，等于变相加薪，仔细思考以下还是划算的。

提高效率

提高效率的过程是有挑战的，在提效的过程中我们获得的锻炼往往是非常巨大的，鸡汤一点提升效率可以让我们成就更好的自己。

获得收入规划化的可能

记得在李笑来的一本书上看到过，说是有钱人总是在请别人来替自己工作，从而获得不需要自己亲自动手就可以自动赚钱的能力。这句话在某种程度上是对的，因为很多产业我们都是通过人力的规划化来进行收入的提升，比如之前海底捞的疯狂开店就是个明显的例子。不过在软件领域，规划化的边际成本相对是比较低的，比如把一个服务十万人的应用扩容成服务二十万人的服务往往只需要增加几台服务器就可以了，成本相对精准可控。实现自动化其实就是实现软件化，既然是软件，那么规模化的成本其实相对就还好了，这样如果你的自动化能力可以给你带来收入，那么你就潜在的拥有了收入规模化的可能。

自动化让生活更美好

当我们不需要从事一些重复费神的工作时，生活自然就会美好一些了吧。

整体看来，我认为这位功成身退程序员的的建议是相当中肯的，对我触动很大，所以我在思考这样一件事情。

怎么让我的生活更加的自动化

自动化往往带来智能化，比如现在一些智能家居产品其实就是这样的逻辑，折腾智能家居意味着硬件的投入，不一定划得来，所以优先级可以放低一些。

下面就是纯软件层面的自动化的实践了，因为打工人一天大部分时间都在工作，所以可以从工作开始。

我写了个自动在测试教程网发布文章的脚本，这样一旦我的代码库里有新的文章提交(是的，我的文章我都用代码库进行管理)就可以自动的发布到测试教程网了(www.testclass.net)
我曾经一上午发布了n篇知乎专栏的内容，触发了知乎的限频逻辑；手动发表文章很心累，而且对我本人没有任何成长，所以我准备写个脚本自动化的去发表知乎专栏以及博客园文章的更新
自动跟踪线上的bug，一旦有新的线上问题就给我发提醒，这样提高了跟进线上问题的效率；
自动对工作进度进行检查，提升工作效率；
自动扫描github的热门项目，有我自定义感兴趣的内容就推送给我，试了一下，不如github自带的explore好用…
自动抢电商平台的优惠券
应该还有更多……

我甚至专门维护了一个自动化idea的列表，有新的想法就写上去，然后抽时间实现。

我还在油管关注了一些知名的博主，这些博主不定期更新一些关于python的视频，这些视频里很大一部分就是如何用python实现一些稀奇古怪的自动化idea，比如一旦某美女模特发了新推就第一时间自动点赞之类的,有些灵感是可以从里面获取的。

期待后面可以实现更多有意思的自动化想法。

总而言之

尽管努力自动化不能使我们一步到位的实现财务独立，但节约下来的时间和精力可以让我们有余地更多的去计划如何扩大收入和减少支出，当你的收入远远大于支出的时候，财务独立也许就触手可及了。

梦想还是要有的，万一哪天实现了呢？

原始封面

又是绩效评估时，如何合理的评估测试同学的绩效?

Tue, 17 Jun 2025 17:29:15 +0800

又是绩效评估时，如何合理的评估测试同学的绩效

这是我最近思考比较多的一个问题，也是很重要的一个问题，因为这关系到大家一年来辛辛苦苦工作的结果。

在我看来，大部分测试同学都是很辛苦的，加班，给开发背锅这些事情都是常态，所以如果没有给大家一个非常客观的年终评定的话，不仅经济收益上会有影响，更有可能打击大家的积极性，从而对团队稳定性造成不好的影响。

绩效评估如果不合理，那么大家可能会有这样的疑惑

我明明工作很努力，为什么绩效这么差
我觉得我的能力很强，为什么不给我涨薪
某某某并不如我啊，为什么绩效比我好

其实测试的绩效比开发同学的绩效要难评估一些。毕竟开发大神大家很容易看得出来，贡献大的绩效好，相对比较容易做比较，但测试同学很多时候技能的区分程度不大，大家其实水平差不多，做的事情也差不多，也都差不多的努力和敬业，尽管很多时候是被动的，但功劳苦劳其实差不多。

如何能够比较好的进行测试同学输出的评价呢？我思考了几个维度，希望可以跟大家讨论一下。

个人能力维度

个人能力包括当前能力及成长。如果个人能力一直没有较大提升，那么可以认为该成员的成长速度可能一般，或者已经达到自己潜力的巅峰了，可以考虑让其承担一些更有挑战的工作之类。

我觉得年终评价的时候我们可能更需要关注成长。主动成长和被动成长从结果上看其实是差不多的，但主动成长的人可能在成长的持续性方面会更好一点。

关于测试同学的能力的评估我之前写过文章描述，这里再列一遍

业务能力，理解业务和快速熟悉业务的能力
文档能力，有时候写文档也很重要
沟通能力，不言而喻
和项目组其他成员打成一片的能力：这个是双刃剑，有时候这种能力强推动力强，有时候则会陷入过度的容忍
技术能力，这里可以很细，就不展开了

业务输出

从结果导向上看，测试同学的输入是质量控制和保障，只要不出问题，没人想起你，那么你就是成功的，否则，如果你成了团队里最让人惦记的人，那么你的质量可能就没有太高。

这里可以给出一些指标，我觉得最简单粗暴的指标就是线上问题的数量。这个指标比较片面，这是因为

可能你在测试过程中发现了太多的问题，但是代码质量实在太差，导致问题一直没有办法根除，从而遗留到了线上，这种情况下，可能测试同学就是线上问题的背锅侠了
如果代码质量好的话，那么测试同学在测试过程中可能不需要太费心，最后上线之后如果发现了问题，那就是运气不好，没有出事故的话，其实跟测试同学的努力关系也不是特别的大，这就是命了

既然这个指标问题那么多，那么我为什么还是推荐大家使用这个指标呢？这因为质量管理不一定是疯狂的点来点去，以自己的一己之力去避免缺陷的发生，而是要将项目组所有成员都拉到质量控制的大流程中去。

举个例子，开发的提交质量太烂，那么能不能提升准入门槛，让他们自己多测一会，多思考一些事情再提交呢？能不能让这个锅大家背，而不是测试独自去承担？线上问题追责的时候，能不能谁写的代码谁承担主要责任？没测出来的最多算个从犯，而不算主犯？有锅大家背，如果开发被背锅的恐惧感支配，那么代码质量多少还是有提升的。

所以这个结果我们是可以基本信赖的，哪怕这个指标有争议，但争议的过程引导我们去做的更好。

另外我喜欢让测试同学站在产品的角度去向整个项目团队去讲解需求，假如你是产品经理，那么你应该怎么向我们表述你的需求？每次讲解的时候当场就可以收集到反馈，这就可以看出另一个指标：业务熟悉程度。

让测试同学写系统或产品的使用说明书也能看到大家的业务熟悉程度，有时候写太麻烦了，所以我倾向让他们讲出来，这也能看出业务熟悉程度。

有了上面一些维度之后，我们可能就能大致的评判大家的工作输出了吧。指标其实还有很多，但核心思想大概都是：看测试质量，看人员成长。

最后，这只是我的个人浅见，仅供参考。

原始封面

在没有线上监控的情况下放肆裸奔

Tue, 17 Jun 2025 17:29:15 +0800

如果你的产品出现了一个线上问题，你会是怎么样的反应？

也许会跟下面这张图一样。

哇！有一个线上bug，好慌呀！！

咦，问题似乎自动解决了？渐渐冷静。

不对！！！这个问题竟然突然自己就好了？？？更慌了！！！

很多测试同学应该有上面这样的心路历程。线上bug不经意间出现，却又突然消失无踪，这会让我们精神紧张，心里各种没底，寝食难安。

这时候可能就需要做一些线上监控和告警了。

其实我之前有分享过，监控可以分为3个层次。

基础监控。线上机器的内存，cpu，硬盘，网卡等核心指标的监控和告警。
服务监控。服务监控程度的监控，比如接口的调用成功率，相应时间，错误码分布等。
业务监控。定义核心的业务指标，比如电商的核心指标就是订单数，对业务指标进行监控和告警，一旦业务指标有异常，立即告警。

基础监控和服务监控大家都比较好理解。这里稍微具体讲一下业务监控。

以电商的核心业务指标订单为例，假设我们通过各种方式计算出在每天下午2点的时候，大概一小时会有1万单，那么如果哪天下午2点左右订单数掉到5000了，那么可能是下单链路上某个环节出问题了，就需要立即排查。

另外业务监控也可以用自动化的方式辅助去做，这样监控的路径会更长一些，排查问题也能迅速一点。

还是以下单为例，我们可以在线上用一个特殊用户不停的买一些特殊商品（当然了，有影子库和特殊策略就更好了），如果下单流程失败，另外数据又监控到订单数环比确实有异常，那么就可以根据自动化用例的报错迅速定位到问题。

最近我们线上出了一次比较严重的事故，当然导致事故的核心原因是开发流程没有正确进行，不过没有线上监控而放肆裸奔也是求生欲不够强的表现，如果一些核心数据可以被监控和告警的话，我们可能在上线之后就能迅速定位到问题，而不会等到用户投诉再去处理了。

我们在线上监控很多时候都是通过阈值去感知变化的离散程度的，合理的阈值会让告警更加精准。不过由于一些突发性的原因，这些阈值可能会在短时间被突破，但是过完一个时间周期之后自动恢复正常，在这种情况下，为了减少误报，我们可能不仅要报异常情况，还要报问题自动恢复的情况。

关于监控工具，目前市面上有很多开源免费的监控工具，都非常好用，比如

prometheus。普罗米修斯，github star超30k，部署简单，功能强大，小白入坑无脑选择的最佳推荐；
open-falcon。小米开源的企业级监控平台，国内很多企业都在使用。高可用易扩展，可以分布式部署，自带dashboard，最关键的是有中文文档，英文拙计的同学可以试试；

2020年大家可以给自己定一个小目标，那就是生产环境的业务监控先跑起来，不要再放肆裸奔了吧。

原始封面

这几家大公司准备干掉测试了，我们应该何去何从

Tue, 17 Jun 2025 17:29:15 +0800

最近因为招聘，所以经常会跟一些比较优秀的大厂同学聊天，无意中得知了这样一些信息。

腾讯的pcg已经在逐步干掉测试了，这是所谓的去测试化。

这里的干掉指的是日常的测试工作交给外包去做，曾经的正式员工往效能提高的方向去转型，做一些研发效率度量，质量度量以及效能提升的工作。

去测试化万口传，至今已觉不新鲜。

最早听说这个词应该是在2016年左右，正好是5年前。当时我们公司来了一批微软的测试专家，从他们口中得知微软总部在去测试化，之前的测试人员转做测试工具或者效率工具开发，开发尽可能的多写测试用例，一些实在需要人工覆盖的场景可以交给外包去做，所以现在微软应该没有测试这个角色了。尽管在做出这个决定的初期，微软产品的整体质量似乎是出现了一些不可避免的下降现象，比如win10之前出过非常多的bug，但是微软后来迅速走出了困境，整体的产品质量有了一定的提升。

不过仔细一想微软是有这样做的资本的。在操作系统领域，哪怕windows的质量有了一定程度的下滑，但是对于大部分人来说，要么是没有选择，只能默默忍受，要么就是选择不升级，停留在之前的稳定版本里。所以对于一个在市场上占主导地位的公司或者产品，没有了活下去的压力，去测试化可能是一个不错的选择。将质量保障的压力传导给开发，这是最行之有效提升代码质量的方法。我记得很久之前分享过，如果一个项目中开发很强，测试相对不强，那么这个项目的质量其实是可控的；相反开发能力很弱，但是测试很强，产品的长期质量我其实是看衰的。再看一些很流行的开源项目，这些项目中似乎只有开发，他们写用例，做code review，发布代码，然后开源项目的使用者其实就是测试，他们试用产品，提出问题，寻求解决方案或者直接贡献代码解决。因此微软的去测试化其实就是让开发多做测试，让用户当小白鼠，反正用户的选项不多，也不是很怕用户流失。

后来在18年左右，又听说一家公司在做去测试化，那就是字节。

当时跟字节的一个部门负责人交流的时候，他说他们很欣赏微软的理念，要对标微软去测试化。测试人员主要的职能有

提升测试效能，让开发会写用例以及提供相应的工具让测试的效率可以提升
测试管理，大体是做流程管理和推动，顺便管管外包和实习生，似乎字节有让实习生做测试的传统

字节和微软不一样，字节应该是一家非常焦虑的公司，偏平的架构和不成功便成仁的kpi导向，使得这家公司的策略可能会偏向激进，所以作出去测试化的策略是可以理解的。毕竟字节产生产品的速度和放弃产品的速度一样快，一个产品因为质量不行而被诟病其实问题比较好解决，要么放弃掉，要么重新做一个。

到了今天腾讯的一些部门也坚定的站在去测试化这一阵营，综合分析起来其实是可以理解的。

来了新的gm，推进自己的技术理念
稳定的产品占据市场主导地位，质量下降带来的副作用在短期内是可以接受的
产品开发的快，放弃的也快，跟字节类似，所以一旦有质量问题，要么重新来做，要么直接放弃
腾讯老一代的开发基本上新陈代谢的差不多了，向这部分人灌输开发做测试的概念其实比较难；但对于新鲜血液来说，推一推总是有办法的

所以我们可以有理由相信，对于一些在行业内有一定垄断地位的大厂来说，去测试化应该是大势所趋。

那么我们测试同学应该何去何从呢？

转型为测试开发，专心打辅助，开发质量度量工具，测试效率提升工具以及其他各种工具，另外还要教开发写测试用例，这是测试左移，可能不需要背锅
大厂不好混可以去二线厂，只要市场没有被巨头垄断，其他玩家必定重视质量和口碑，这里测试同学的机遇和挑战并存，可能需要背锅
转型为测试管理，大厂还是要有人做流程管理，外包管理，质量管理，职位不多，但有需求
转型为开发，说句实话，在相同的预期条件下，写业务逻辑很多时候比写工具要简单，不过转开发要趁早，因为对于开发来说，你之前的测试经验可能是一文不值的
转产品，我认识好几个转产品的测试同学，还是同样的道理，转要趁早
转行，换个行业和赛道，想象的空间可能更大

不知道大家有什么样的想法，欢迎在评论区留言讨论。

原始封面

这也许是最硬核的自动化测试机器人

Tue, 17 Jun 2025 17:29:15 +0800

当你用chrome浏览网页的时候，你可能会经常遇到这样的一幕。

没错，这就是没网络时候的默认的界面。

不过有多少人知道在这里点一下空格键，你将会开启一个全新的游戏的世界。没错了，这里google放了一个小小的彩蛋，当没网络提示出现之后，按空格键将会启动一款名叫dino的网页小游戏。

这款游戏玩起来非常简单，玩家扮演一只名为dino的小暴龙，dino每天的工作就是不断的向前跑(脑补BGM:向前跑迎着冷眼和嘲笑，生命的广阔不历经磨难怎能感到…..)，这一路艰难险阻，会突然出现各式各样的大小仙人掌等障碍物，玩家需要操控dino上蹿下跳来躲避这些未知的危险。游戏操作非常简单，只需要用到空格键或者向上的箭头键，节奏明快，很上头，一不小心就会玩很久。

除了断网的时候可以跟dino小恐龙不期而遇之外，我们还可以在chrome浏览器里输入chrome://dino/，这样就可以直接打开游戏了。

这款彩蛋小游戏其实很多人都知道了，而且也有不少人手上把玩过一番，大家可以把自己的最高分留言在评论区里，比一比谁更无聊。说起冲击高分，最近我看到有个老外搞了套硬核的自动系统，号称可以独孤求败，把这款游戏玩到天荒地老。废话不多说，直接上视频。

小朋友，你是不是有很多的问号？

这个是怎么实现的呢？

其实我也不知道。不过我猜也许这是通过树莓派+传感器实现的，具体原理可能是

利用光感电阻和电容进行串联，实现测光的效果，可以设计成也是有光的时候是高电频，弱光的时候是低电频
当光敏电阻识别到是弱光的时候，发送指令给机械臂，按下空格键，实现dino跳跃的效果

所以理想情况下你只要会设计电路，熟悉树莓派编程，外加上运气好，你就可以实现同样的效果了。

是不是有点硬核？不过这套系统可能会存在这样的问题，就是在外部的光线情况变化了的情况下，比如晚上光源比较弱的时候，这套系统可能就没办法工作的很好了，因为那时候dino可能会不停的跳来跳去，变成一只飞翔的恐龙，降落的时候踩到仙人掌，那可就game over了。

瑕不掩瑜，这个例子告诉我们，只要脑洞够大，我们日常工作生活中能用到自动化的地方其实会有很多。世界上不缺乏需求，缺的是发觉需求的能力以及实现需求的勇气。记得当初在宜家里看到过自动测试柜门的机械臂（大概是这个，记的不是很清楚了），就是让机械臂不停的去开关柜门，进行持续的磨损测试，这种测试只能机器去做了，这是自动化的典型应用场景。另外我也有过耳闻有团队使用树莓派加温度传感器去自动化测试手机温度的案例。

dino玩到后面难度其实会增加的，恐龙移动的速度会随着分数的提高越来越快，这时候可能要通过调整光感电阻的位置来实现提前跳跃的功能，所以上面的装置应该并不是可以一帆风顺的直接跑下去的。另外第二关整体的背景会变成黑色，这对光感电阻也是很不友好的，那么有没有什么办法可以让dino一直跑下去跑到天荒地老呢？

答案是有的，看下面的视频。

在这个视频里，我其实就是做了3件事情

把障碍物小仙人掌的y坐标改成0，这样小仙人掌就飞升了 Obstacle.types[0].yPos = 0
把障碍物大仙人掌的y坐标改成0，这样大仙人掌就飘走了 Obstacle.types[1].yPos = 0
把障碍物翼龙的各种坐标改成0，这样就飞龙在天了 Obstacle.types[2].yPos = [0, 0, 0]

这样一来所有的障碍物都成了热气球，dino就可以永远的奔跑下去了吧。

说回测试，上面的例子在游戏测试中其实有可能会用到，这是一种简单的跑关的方式。

在做游戏测试的时候，我们需要验证我们的关卡设计是不是符合预期的，关卡设计中的梗能不能被玩家get到，比如dino的后面关卡中的深色背景梗，这时候就需要我们有快捷的方式去把所有的关卡跑通，而上面把障碍物全部放风筝的做法就可以很好的让关卡一直跑下去，简单的人工介入之后就可以做基本的测试和检查了。另外在一些游戏里会有一些经典的bug或者秘籍，比如魂斗罗的上、上、下、下、左、右、左、右、B、A、B、A 30条命秘籍，这些也许是当初为了测试游戏时候为了大幅度降低游戏难度，从而减少跑关时间所留下的后门。这种后门其实在软件开发领域很常见，比如测试环境上的万能验证码后门。

无论是硬核的树莓派周边解决方案，还是代码流的改运行时的方法，我们的初衷都是遇到问题，然后解决问题。

使用自动化的方式去提升测试效率，解决测试工作中遇到的特定问题，这是大家都广泛认可的观点和方案。有时候自动化做不好，可能并不是工具的锅，而是大家也许没有把有限的精力和能力用在最合适的场景上吧。

原始封面

主力机从iphone换到android是一种什么体验?

Tue, 17 Jun 2025 17:29:15 +0800

我的主力机最近6年应该一直都是iphone。从之前iphone 5s到iphone se再到iphone 8，基本上ios设备都能很好的满足我的日常需求，直到我的icloud存储空间捉襟见肘以及我的ip8陷入深深的电量焦虑之后，我感到是时候换一部新手机了。

坦诚的说，iphone 8是一部不错的手机，尽管已经2020年末了，但是ip8的反应速度还是让人基本满意的。不过ip8现在待机时间确实有些让人着急，加上非全面屏的设计看上去有些怀旧，另外不支持双卡，所以还是换一部好了。

继续换一部ios设备？

因为我使用苹果的生态很久了，icloud的各种同步，mac和ios设备的协同，以及ipad os设备跟ios的设备的无缝衔接，继续使用iphone应该是一件顺理成章的事情。

正好这时候iphone 12发布了，支持5g，支持双卡，屏幕手感响应速度都有提升，那么我的下一台iphone就是iphone 12好了。

不过128g 6000+的售价会让我原本不富裕的家庭雪上加霜，思索良久还是放弃了，毕竟十三香，再等等吧。

这时候iphone se2进入了我的视野，128g的售价是2800左右，经济上还是可以承受的。不过考虑到iphone se2跟我的ip8长得一模一样，似乎换机对体验的提升并不是很大，还是不要考虑了。

所以，最终我的决定买一台iphone 12给我老婆，这样我就可以用她的iphone xr了，曲线救国也是可以的。但是老婆大人对换手机没有任何兴趣，因此只能作罢了。

只能换安卓设备了

为了获得不一样的换机体验，我将目光放到了安卓阵营，现在安卓手机的流畅度基本上跟iphone差距没有那么明显了，而且安卓手机可选择的余地很大，尽管长的都差不多，但总有一款大致可以适合我。

我的需求也很明确

不要太大太重，现在中低端安卓机器基本都是200g左右，长期使用有健身的效果，手感其实是不如iphone的
支持5g和双卡，这些都是标配了，闭着眼睛选就好了
待机能力强一些，有很多安卓机支持65w甚至是100w的快充，基本可以做到续航不焦虑了
屏幕大一点，这点其实可以不用过多考虑，我发现现在基本找不到小屏幕的机器了
便宜一点，这点其实最重要

于是搜索了一段时间之后，我买了一台某品牌的 8+128g的手机，重量175克，算是相对轻一点的了，支持屏下指纹和65w快充，最关键的是只要1299，这个价钱就不要自行车了。

主力机的体验

因为我不玩手机游戏，其实也想玩，但是之前ip8只有64g的空间，装应用都不够，更别说是装游戏了，所以买小存储的空间的手机可以帮你戒掉游戏，这不仅是我的体验，我另一个只买乞丐版手机的同事也有类似的心路历程，换了乞丐版iphone以后，直接从王者变成青铜。

因为之前的手机的存储空间小，而微信又非常吃空间，所以我基本上不必要的app都不会装，而我常用的app都有android版本，尽管没有iphone那么优雅，不过用起来其实也差不多。

另外由于手机支持双卡，现在出门就不需要带两台手机了，减少了很多负担。

128g对我来说是相对奢侈的，之前iphone只敢用来扫码，不敢拍照，现在用android机器可以适当拍照了，不过千元机的拍照水平不敢恭维，画面还是比较容易失真的，所以大部分时间可能还是用来扫码。

所以对于一个主力机只用到微信，邮件，浏览器(有浏览器端的站点坚决不装对应的app)以及一些视频应用的手机中度用户来说，iphone和android的体验差距其实没有那么明显。

iphone更加优雅，安全，稳定，高效，就像是理想中的初恋情人，你想要的她都有，符合你对一台手机的几乎全部定义；而安卓则像是现任女友，优点很明显，但总有一些地方让你难以忍受。

而从iphone换成android的体验就像是你一直在听经典的古典音乐,沉浸于那种美感那种韵律那种从容，忽然转为听流行音乐，有一些地方一开始你确实非常欣赏，但听了久了就有一些乏善可陈，流于表面。

但总的来说，如果你一天大部分时间都是在办公室里度过，作为专业社畜和资深打工人来说，而手机只是在通勤的时候中度使用的话，用iphone或者是android差距其实是不大的。

得到和失去

从ios转向android，有得有失

没有了ios，我将

carplay不能用了，这点最让人遗憾
ios/ipad os以及mac os之前无缝转换的生态体验没有了
再见siri，别了捷径
不能用ios原生的记事本和提醒了
失去了icloud同步一切的能力
失去了一款方便携带的小屏手机

得到的也有一些

不用电量焦虑了
不用容量焦虑了
屏幕更大了

总之经过这次换机我发现，社畜用啥机器都差不多，只要便宜稳定就可以了。

原始封面

自动化测试元素定位最佳实践

Tue, 17 Jun 2025 17:29:15 +0800

最近在翻阅cypress文档的时候发现一些关于自动化测试中元素定位的思考，觉得很有意思，这里跟大家分享一下。

核心概念

其实元素定义的核心概念很简单，一些元素总有自己独一无二的一些特点，比如我们每个人都有身份证号，利用这种独特性对元素进行定位，从而进一步做后续操作。

有道是君子有所为有所不为，一些在实践中被证明了是不合适的做法是最好不要去采用的，比如不要使用有可能发生改变的属性对元素进行定位。

如果你有能力修改前端代码，那么最佳实践就是:加一个定位专用的属性，比如data-*，这个属性跟js逻辑以及css样式都无关，这样就做到了定位属性与易变属性(dom/css selector/js selector)隔离。

下面的一些做法是cypress不太推荐的，不过见仁见智，不推荐不代表完全不能这样做。

不要用css属性定位，比如id,class,tag
不要用可能会发生变化的文本文字进行定位，比如按钮上的文字等

没有对比就没有伤害

cypress的最佳实践里给大家列举了一些例子进行对比，我们感受一下

选择器	推荐程度	备注
`cy.get('button').click()`	永远不要这样做	最差的选择，没有任何上下文，太通用
`cy.get('.btn.btn-large').click()`	永远不要这样做	很差，这些class很容易发生修改
`cy.get('#main').click()`	不太好	还行，不过还是跟js和css选择器耦合在一起
`cy.get('[name=submission]').click()`	不太好	跟html的name属性耦合在了一起
`cy.contains('Submit').click()`	见仁见智	好多了，但是仍然跟按钮文本耦合在了一起
`cy.get('[data-cy=submit]').click()`	最佳选择	单独的属性，与css和js隔离

然而，人生十不如意有八九

上面的一些观点，原则上我是非常赞同的。

但是呢，现实往往比理论更加立体，cypress的理念是对于被测项目的前端代码，你必须百分百有控制权，也就是说你需要是这个项目的前端开发人员。

cypress就是为前端开发人员设计的，这样的要求自然是合情合理的。

但很多情况是我们其实并没办法修改前端代码的，在这种艰苦的条件下，一些妥协是可以有的，比如

可以用html的name属性定位，因为这个属性相对稳定
可以用dom的id属性定位，因为改id的概率可能会比较低
不要用基于dom层级关系的xpath或css定位，这里一般指的是在浏览器上直接拷贝出来的xpath和css选择器

总之最佳实践是有前提的，不需要一味的去迷信最佳实践,在我们的工作场景中找到最适合自己的最佳实践才是王道。

原始封面

自我隔离期间疯狂上公开课是种什么体验

Tue, 17 Jun 2025 17:29:15 +0800

自我隔离期间除了网络偶尔会延迟飙升之外，少了日常2个小时的通勤时间还是令人极度舒适的。

怎么把这2个小时利用起来呢？我觉得可以给大家多做一些分享。

说做就做，于是便开始张罗周期性（高频次）的以公开课的形式给大家分享。

每次分享一个点，不贪多，但求把问题说清楚，让大家能够理解掌握，在日常工作中能用起来，最不济面试的时候听到相关概念不至于露出窘迫而不失礼貌的微笑。

准备公开课其实比较麻烦，首先是选题，这是要掉头发的。

然后便是准备内容，为了不翻车，头发也会少一点。

接下来还要不厌其烦的通知大家，手指头会有点累。

最后要编辑视频，上传以及各种通知，也是有工作量的。

作为对重复工作相对抵触的人来说，每次这么搞有点累，不如就在这里一次性说明清楚好了。

我们基本都是在B站进行直播，我们的B站账号是测试圈TC，和微信公众号同名。

点击文章最后的【阅读原文】就能到我们的B站主页，有B站账号的同学可以关注我们，没有账号的同学收藏一下就好了。

公开课1群微信群已经满了，没有加过1群的同学可以加2群，下面是二维码。

如果二维码失效，可以联系我们的报名妹子加入。下面是她的微信号。

那么这么多天我们上了哪些公开课呢? 点击文章最后的【阅读原文】可以回看

UI自动化实战：selenium最简项目实战: 用史上最简单的用例编写过程向大家展示了如何快速进行UI自动化测试
学会就能涨工资？接口自动化测试王道==单元测试框架 + 自动化脚本：接口自动化测试其实并不难
测试同学必知：测试用例的灵魂——断言：学会给用例注入灵魂
测试小白也能理解的测试驱动开发实例：写不完的用例，永远搞不懂的测试驱动开发
测试同学的核心技能：python单元测试入门：练内功的入门级心法
测试世界的核心原则——3A原则：构筑你的测试世界观和职业格局
只用python3+postman实现接口自动化功能测试用例：只用python核心库也能写接口自动化用例
python+postman+requests+assert实现接口自动化测试用例：不用测试框架也能凑合写用例
接口测试环境配置(python + requests)：环境搭建，从入门到放弃的起点
如何预习python语言：我也忘了是讲啥的了
乙醇的性能课程之siege性能测试实战：很多年前性能课的一节内容了

记得点击文章最后的【阅读原文】可以回看哦。

原始封面

最近，我把之前的一些测试技能相关视频转移到了B站

Tue, 17 Jun 2025 17:29:15 +0800

之前录过一些视频放在腾讯视频和腾讯课堂，最近正好发现有些视频过期了，于是顺手就转移到了b站。

现在转移了下面一些内容，以后会逐步更新。

接口测试入门：postman的简单使用

这一系列视频的目的是帮助大家快速的掌握postman简单使用和稍微深度一点的功能。

其实postman除了是调试工具以外，还可以很方便的帮我们进行一些日常的接口自动化功能，比如postman支持断言，有了断言就有测试的可能，jmeter也是同理。

这一系列视频花费了不少的精力，有19期，内容也算循序渐进，希望对大家能有所帮助。

纯粹测试：测试杂谈系列视频

这一系列视频是之前录制的测试技术杂谈视频，现在发现还是有一些干货的，可以帮助大家扩展一下技术视野。

由于视频需要重新剪辑，需要花费大量时间，所以尽量每周更新一次。

另外视频剪辑的技术我也是刚刚尝试，后面我会尽量提升质量，比如背景音乐我会尽量低调一点。

短小精悍的技术视频

这是我全新制作的2到10分钟的技术专项小视频，可能就一个小点做快速分享，让大家在最短的时间掌握一些会者不难，难者不会的技能。

上周录了一个jmeter的使用小技巧，那就是永远都不要用gui模式做性能测试，如果大家对这类视频反馈良好，我会不定期更新。

现在就点击下面的阅读原文查看吧。

原始封面

最中二的性能测试工具--vegeta

Tue, 17 Jun 2025 17:29:15 +0800

在github上翻到一个项目，名字叫vegeta，看到这个单词，你的第一反应是什么？

说来惭愧，我的第一反应是这个单词很奇怪，并不认识。

直到我往下翻，看到了这样一幅场景。

这……这不是儿时的回忆，七龙珠里的天字第一号配角，贝吉塔么？

贝吉塔，日本漫画及改编动画《龙珠》系列中的主要角色。是战斗民族赛亚人的王子，拥有极高的自尊心。过去贝吉塔行星被弗利萨毁灭后（不知情，一直以为是被陨石撞击而毁灭。）在弗利萨军团那儿做事。初登场时是个侵略地球的反派角色，后被孙悟空（赛亚人卡卡罗特）等人打败。弗利萨一战结束后听说悟空成为超级赛亚人，于是决定以超越悟空为目标，一直留在地球上努力修行。多次和悟空保护地球。在人造人篇中学会了超级赛亚人变身，起初只是想着超越悟空才呆在地球，后来有了家人后慢慢的爱上了这颗星球，在与布欧一战中为了保护地球决定与布欧同归于尽。后复活为悟空制造元气弹争取时间，击败布欧后仍为了超越悟空而努力修行。

贝吉塔（Vegeta）与其弟弟塔布尔（Table）的名字合二为一（英文名）就是Vegetable（蔬菜）

上面的描述来自百度百科，所以贝吉塔在漫画中是一个出道即巅峰，登场超强，然后一直被悟空超越，并且打不过就加入你的角色。

可能对于很多读者来说，七龙珠这个上古漫画其实是熟悉而又陌生的，名字都听过，但至于漫画主要讲了什么，大家可能并不清楚。不过对于我这种老古董来说，七龙珠就意味着童年闲暇时愉快的阅读时光以及无数次的练习冲击波以求有朝一日能拯救地球的中二幻想。

怀着强烈的好奇心，我真心希望看看这个中二又复古的项目究竟是做什么的。

经过几分钟的探索，我发现vegeta其实是一个用go实现的性能测试工具，江湖上各种性能工具可谓是灿若星河，那么vegeta凭什么可以获得16.3k的star呢？

可能是因为名字，毕竟github上的中老年宅男还是非常多的。

不过玩笑归玩笑，作为性能测试工具，vegeta有个很不错的特性，那就是可以默认以一定的qps对被测服务进行压测。

固定qps的使用场景

比如我们经常需要对某个微服务进行单实例的容量评估，我们希望某个服务A他能承受的最大QPS是1000，这时候我们就需要有一个工具能持续产生1000qps的负载进行一段时间的压测，这段时间里，我们可能通过监控系统的核心指标来判断系统的健康度和稳定性，vegeta看上去是可以满足这个场景下的压测需求的。

安装

vegeta只支持linux以及mac系统，不支持windows。

vegeta只是一个可执行文件，所以直接下载就好了，下载地址是：https://github.com/tsenart/vegeta/releases

简单的使用

通过命令行使用，命令如下

echo "GET http://localhost:8080/api/articles/" | ./vegeta attack -duration=10s| tee results.bin | ./vegeta report

执行结果

Requests [total, rate, throughput] 500, 50.10, 50.10
Duration [total, attack, wait] 9.981s, 9.98s, 610.816µs
Latencies [min, mean, 50, 90, 95, 99, max] 310.733µs, 549.662µs, 522.345µs, 706.005µs, 814.544µs, 912.57µs, 3.088ms
Bytes In [total, mean] 16500, 33.00
Bytes Out [total, mean] 0, 0.00
Success [ratio] 100.00%
Status Codes [code:count] 200:500

看到这个结果我不禁陷入了深思，因为qps实在是太低了。

这样的面试你能通过吗

Thu, 13 Jun 2019 11:49:49 +0800

近两周我的面试非常多，大概一天一个。我是二面面试官，一面是技术面，有一定的难度。按道理来说二面的通过率应该比较高才对，不过最近的二面通过率可能不到50%，一面的通过率一般比较稳定保持在30%以下，所以两面全过的概率大概只有15%左右，可能更低。

那么二面的通过率为什么那么低呢？我想举几个例子就可以说明了。

二面我一般都会问一道用例设计题，大概是给你一袋盐，或者给你一件衣服，写出一些测试用例。

我的心理预期是15个可执行的用例。

有的候选人是这么回答的。

假如是一袋盐，那么要看看装盐的袋子是不是会漏？

这时候我一般会反问，那应该是要漏还是不要漏？很多候选人这时候会愣住，可能完全意识不到我为什么会这么问。

我这么问是因为我有个怪癖，那就是我希望测试用例都是可以执行的。可以执行的意思是，你要告诉我你究竟是希望袋子漏还是不漏。如果你希望袋子是不漏的，那么袋子漏的时候测试用例就是不通过的，反之也成立。如果你告诉我看看袋子漏不漏，那么因为我是很笨的，我不知道如何去执行这个用例，因为我不知道袋子究竟是需要漏呢还是不能漏。

与之类似的，在测试衣服的时候，有的候选人会回答要看衣服的尺码是不是合适。那么我会反问，对于L号，衣服多长是合适，多长又是不合适呢？这是因为合适不合适是没有执行标准的，对于一个身高不高的人——比如1米49家穷人丑的我——来说，L号是不合适的，太长了。而对于身材匀称的其他人来说，L应该是合适的。所以合不合适没法量化，加上又有模棱两可的是不是这样的词语推波助澜，这种用例执行起来是相当困难的。

所以写用例，要想可执行，首先的第一条原则是，不要包含一些似是而非的词语，比如是不是，要不要，有没有之类的。换句话说，就是用例里大概率要么包含是，要么包含不是这样的词。

比如

装盐的袋子不能（不是）漏
衣服的颜色是红的
衣服的材料是80%的棉，20%的涤纶

像这样的是或者不是的句型，我们可以称之为断言。

上面是最基本的用例设计，主要考察的是思维的全面程度，以及设计用例的最基本要求——可以执行，没有歧义。另外我还喜欢根据候选人的经历去问一些稍微有技术深度的问题。

如果有候选人有性能测试的经验，那么我会问他关于他被测系统的系统架构问题，架构图起码大致要能画出来。这是因为如果不了解系统的架构，那么测试环境搭建，测试策略的选择都会难以下手，测试的结果也比较难有可信度。

如果候选人的简历上写有精通/熟悉mysql调优，那么我就会问为什么mysql用主键去查询会很快？mysql的主键和数据都是怎么存储的？能不能画一下mysql的B+树的大体结构？什么是联合索引？给你几个真实的例子，你能告诉我索引命中的情况不？这些问题其实做过mysql性能调优的同学应该大体都会，没做过的话可能就是强人锁男了。

简历上写精通python的同学我大概率会让他在现场写一个生成器的例子，并介绍一下生成器的主要应用场景。写精通selenium测试的候选人我会随便开个网页，指定个元素让其当场定位。写精通appium的同学我会让其解释appium协议与webdriver协议最大的不同点。诸如此类，在兼顾考察广度的情况下顺便考察深度。

看上去是不是很难？

其实不然。基本上我不是很关注候选人技术深度题有没有答出来，如果是二面的话。大部分情况下，候选人无法通过面试的原因大抵都是用例设计能力不过关。要么设计的不够全面，要么就是基本没有可执行性。

技术不好的话其实是可以教的，用例设计的不好那么入职以后可能还没等到好好教就出线上问题了。

写好每一条用例，大概应该是很多测试同学厚积薄发的第一步吧。

原始封面

还是少背锅吧--聊聊线上监控

Wed, 03 Apr 2019 02:10:24 +0800

之前应该有写文章探讨过测试左右移的问题。

左移大致就是在设计的时候，写代码之前先把问题考虑清楚，尽量减少一些伪需求和自相矛盾的需求，要求测试同学有较大的业务能力。

右移就是上线之后通过监控等手段去提前感知线上的问题，争取在大部分用户发现问题之前就感知到问题并且快速修复和发布，没有被用户抓住的问题其实影响范围是有限的，可以想办法消化掉。

从软件测试的生命周期上看，大部分项目可能都会经历发布上线和线上运行/运营的阶段，从绩效层面上看，线上问题对绩效的影响是很大的，起码从感觉上来说是这样的。比如某测试同学工作兢兢业业勤勤恳恳，但是由于某天线上出了一个很严重的问题，造成了经济损失，通过回溯和复盘，发现该测试人员应该负主要责任，如果你是他的上级，你会怎么评估他的绩效呢？是采取人非圣贤孰能无过，知错能改善莫大焉的态度，还是因为严重的线上问题全盘否定他的付出呢？一般来说，你可能会采取比较中庸的做法，事故责任是要承担的，但瑕不掩瑜，还是会有值得肯定的地方。这时候往往就是把大锅分成一个一个的小锅，找人一起背。不过测试是甩锅链中比较弱势的一环，也是背锅链中首当其冲的一环，还是要有比较强的求生欲以及良好的心理素质才可以。

把线上监控做完备是求生欲强的表现之一。

简单起见，我们把线上监控分为3种类型，分别是业务级，服务级和硬件级的监控。

业务级。业务级的监控需要大家去定义一些核心的业务指标，然后对指标进行监控，如果指标有异常那么争取迅速定位问题，将业务重新推上正轨。拿电商业务举例，核心指标可能是订单量，假如平时下午2点到3点左右的平均单量是1000，但今天只有100，那么应该是哪里出了问题，需要迅速去定位和排查。如果订单数直接掉到0，那么可能是订单服务不可用或者整站都挂掉了。
服务级。比如订单服务一共有10个接口，那么每个接口的调用次数，成功率，返回速度等。服务级的指标可以分的很细，每个团队每种业务都有不同的服务级指标的着重点。
硬件级。这个比较好理解。比如可以看到某台服务器的cpu内存网卡等指标。

谁来做

监控谁来做是个老生常谈的问题。一般来业务级监控需要测试+产品+运维的同学一起来做，运维可以主导，测试同学可以辅助验证或验收。服务级的监控可以由开发+运维+测试来做。硬件级可以由运维同学主导。

3层是不是都要做

一般来说3层都做的话是比较好的。比如业务级监控发现了订单量异常，然后通过服务级监控发现订单服务的库存接口调用失败率很高，导致订单无法正常创建，最后通过硬件层监控发现库存服务的硬件服务器磁盘io异常，从而可以快速定位到问题，迅速修复。

如果没有精力把3层都做全的话，可以先做业务级，至上而下把3层逐步建设好。因为业务级的监控往往非常直观，有锅自远方来可以一目了然，做好业务层监控可以提高一些存活率，不过如果想把线上问题的影响降到最低，另2层也是需要建设完备的。

并不是所有的问题都可以监控到

有时候我们并不是所有的问题都可以监控到，或者有一些监控的指标由于跨部门，或调用第三方服务的关系，我们没办法拿到我们想要的核心指标或数据。这时候我们可能需要模拟线上用户的一些具体操作去感知问题。举个例子，目前订单系统支持微信支付和支付宝支付，默认情况下展示的是微信支付的链接。我们可以通过在线上真实下单的方式(自动化测试的手段)去调用微信支付接口，如果可以正常走完流程，那么微信支付应该是没有问题的，如果走不通流程，那么微信支付可能暂时不可用，我们可以迅速把默认支付方式切成支付宝，这样可能对订单量不会造成特别大的影响。

告警

监控往往跟告警结合起来，比如我们可以设置高峰期每十分钟的订单量如果小于100就通知相关人员进行故障排查。告警往往需要非常精准，因为如果老是误报，那么大家可能会习惯性的忽略告警信息，导致告警形同虚设，那就是狼来了的故事了。

综上希望对大家有所帮助，另外作者水平有限能力一般，有问题还请斧正。

原始封面

如何提升测试水平

Sun, 06 Jan 2019 10:20:24 +0800

有同学在公众号留言问如何提升测试技能，这里抛砖引玉给一下个人不成熟的建议，大家见仁见智，欢迎讨论。

熟悉业务

让人称赞和放心的测试同学往往对业务是非常熟悉的，知道自己的业务在干啥，知道业务的商业逻辑和非商业逻辑，其实对于测试同学来说是蛮重要的。

熟悉业务的方式有很多，一般来说刚接触到新项目/新产品的同学往往会先体验一下产品，把这个产品的功能先点一遍，就当作是熟悉业务了。这样做没什么不对，不过有点不够深入，不理解产品的设计逻辑。理解了产品的设计逻辑才能更好的贯通整个产品的各个模块，真正做到精通。

在熟悉业务的时候，我们可以问自己下面的一些问题。

用户想要什么？用户的原始需求是什么？有些产品可能用户是没有直接需求的，完全是通过产品去创造需求的，这样的产品原始需求可能会比较模糊，理解起来会有点难度。还有些产品是直接照搬或者高仿友商的，理解这些产品的原始需求可能就要深入理解竞品了。
我们提供了什么功能？为什么？这是我们自己产品的逻辑了，用户的需求我们可以一步一步慢慢去满足，先实现哪些后实现哪些，这些逻辑我们也要搞明白。另外有时候实现用户的需求成本很高，因为成本的原因我们可能提供一些有损或者折中的方案，这种逻辑也是测试同学所需要了解的。
赢利点在哪里？这个比较难，我们靠什么赚钱？这个老板会比较关心，但是测试同学最好也关心一下，毕竟赚钱的地方往往是最最严重的缺陷发生的地方。电商平台的支付如果出了问题，那么这个事故的严重程度大部分情况下是最高的。福兮祸之所倚，祸兮福之所伏。
有没有运营数据？运营数据怎么样？运营数据反应了线上的真实情况，能帮助我们更好的理解用户的行为，从而改进用例的优先级以及设计更加直击痛点的用例。

了解实现

我们的系统是怎么样实现的？代码的逻辑是什么？代码出错以后的异常处理是怎么样的？这些问题我们最好能多少了解一点。

如果大家对上面的问题感到棘手，那么可以思考另外几个问题，其实也是殊途同归。

数据库每个库每张表是做什么的？每个表的每个字段是做什么用的？关联关系是什么？(如果是关系型数据库的话)
系统有没有用到缓存？缓存里存些什么数据？这些数据会不会过期？过期策略是什么？
有哪些定时任务在跑？为什么要跑定时/延时任务?

把上面一些问题弄明白了的话，在面试的时候也是有一定好处的。

了解架构

一般来说我们需要了解逻辑架构和运维架构。比如逻辑架构里的一些微服务模块，每个微服务的功能是什么，怎么跟其他微服务交互的，完全从逻辑的角度去看。

运维架构可能涉及的点会多一点，比如用户微服务部署了2个实例，负载均衡用的是xxx，如何动态扩容之类的。

这些在面试的时候是很好的谈资，很容易加分。

掌握专项

功能测试的话开发也会测，产品也能测，看上去并不是什么特别专业的技能。

专项的话呢，开发可能要学一下才能会，产品可能一时半会学不会，嗯，终于有了点领域独占的优势，是大家提升技能时可以重点考虑的部分。

性能专项。服务器性能比较有技术含量的。
移动端专项。移动端的性能稳定性等。
自动化专项。ui自动化和接口自动化了。
安全专项。我也不会，白话不出来。
监控专项。各种监控也是很有意思的。

好了，以上就是我的一些非常不成熟的见解，有些应该是臆断，求同存异，希望对你能有所帮助。

原始封面

你是怎么样跑测试用例的呢

Tue, 01 Jan 2019 10:10:24 +0800

大家应该都有过写测试用例的经历。

我的经历大概是这样的。

十多年之前刚入行的时候是用excel写用例。大概就是往模版里填充一些必填字段，比如用例编号，名称，步骤，预期等等。那时候啥都不懂，预期里基本上是随心写，填的都是"应该正常执行", “结果应该正确"之类的写了等于没写的话语，无非就把格子填满，显得很有工作量的样子。执行用例的时候基本上是看需求文档，自己写的用例也不看，测完了就无脑打勾，显得工作是按时按量完成了的。

后来很多年用例管理也一直没有改善，无非就是excel换模版，然后用打勾的形式去表明工作已经完成。这是手工执行的方式。

也经历过很长一段时间用自动化的方式去运行用例的情况，这时候用例基本是代码，代码是经常要去更新的，以便增强稳定性和更新业务逻辑。这时候报告和日志比较重要，因为跑出问题之后需要通过报告和日志迅速去定位问题，提bug或者再人肉验证一下。

再后来便是开发了一些测试用例的管理系统，自己用起来还行，无非就是把excel填格子的过程改成了从网页上填表单，但是推广的时候遇到了很大的阻力，毕竟大家还是习惯于用excel去管理，在写好了execl之后导入到系统里，整个系统除了执行的时候可以体现用例状态之外，其他的话意义不是很明显，而且很多时候，用例的执行状态并不是大家关注的重点，所以用例管理系统后来也没太多任用，荒废掉了。

近些年很多同学用脑图的方式来管理测试用例，等于就是把需求换个维度整理了一番，变成了一个个的场景或者检查点，测试的时候可以对照着检查点来，比excel有不错的提升，可以推荐大家试一下。

脑图其实是整理+记录的过程，很像是我们之前初高中时候老师写的板书，好发散，格式比填格子灵活。我建议可以不用在脑图里写预期结果，执行完成之后再补充也行。

写脑图可以用场景导向，枚举大部分的异常场景可能会比较的有价值。

如果写了用例但是测试的时候不去对照着看或者执行，那么写不写都无所谓了。真正有价值的用例可能是

自己测试的时候会去对照着看或执行
大家都能看懂
保持跟最新的需求同步

最后给一张最近关注度比较高的个税脑图，这个图基本上算是非常全面的测试检查点了，大家可以参考一下。

原始封面

自动化测试如何准备测试数据

Thu, 22 Nov 2018 11:10:24 +0800

其实大部分类型的测试都需要去准备测试数据。

手工测试：一些基础数据，比如配置数据等等是需要去准备的；
自动化测试：基础需要准备，现有数据，动态运行时产生的数据是需要准备的；
性能测试：跟自动化测试差不多；

这里就牵扯到了一些关于数据的概念了。

测试数据的分类

我们可以给测试数据分一些种类

基础数据，比如一些内容管理系统会配置站点的标题，友情链接之类的基础配置数据
存量数据，也就是现有数据。比如在测试一些电商站点的时候会提前插入一些商品信息，类目信息物流信息等
动态数据，也可以叫做session数据。比如在测试电商站点的发布商品功能的时候，往往会去创建一些新的商品

我们可以想象到，基础数据其实可以比较容易的跟生产环境保持一致。测试环境的存量数据会比线上环境要少，测试环境的动态数据可能不会像线上环境那样真实。

这里就需要讨论测试数据的量级和真实性的问题了。

测试数据的量级

大部分情况下，测试数据的量级是没有产生环境多的。所以测试数据可以是真实数据的子集。

如果有类生产环境或预发布环境的话，可以尽量保持跟线上数据相当的量级。这样一些测试环境不好测出来的由于数据量导致的问题可以在预发布环境测出来。

测试数据的真实性

我们测试环境的数据往往跟真实用户产生的数据是有差异的。比如测试论坛系统时，我们在帖子里的贴图可能往往就那么几张，尺寸也是恰到好处，而线上用户的贴图可能是五花八门，从而导致意想不到的问题。

如何准备基础和存量数据

基础和存量数据与线上环境越一致，测试中发现问题的概率可能就越高。一般来说，可以有下面的策略

全量+脱敏策略。直接定期把线上的数据做脱敏，导入到测试环境。这里脱敏是必选，数据泄漏导致的问题严重程度往往比普通的线上bug要严重得多。
定量+脱敏策略。只上一些线上数据，比如只在线上拉1000个商品，1000个用户信息，然后做脱敏。这里技术实现难度会比较高，毕竟要把关联表理顺。
爬虫策略。如果是新项目/产品的话，线上没有存量数据可以导，那么可能要去友商那里爬一些数据，导到测环境做测试。比如做一个旅游站点，开始的时候是没有用户的游记的，这时候就要去类似站点爬一点来测试了。
生成动态数据。如果线上没有数据，友商也没有的爬，那么就要人肉或者自动化的方式去产生一些数据了。系统简单的话可以用sql去跑，复杂点的话可能要调用接口或者用自动化的方式去生成。实在没辙的时候也可以手动去造一些数据。

关于动态数据

大家在做自动化或者接口测试后往往会大量的去产生动态数据。那么问题就来了。

这些数据存在哪里？什么意思呢？如果我们需要用自动化的方式去创建一个商品，那么商品的信息，图片地址该放在哪里呢？其实这是个持久化的问题了。

放文件里。文件格式有很多可以选的，比如xml/csv/json/yaml等。不过不推荐excel，毕竟是私有格式，没有太强的扩展性。而且excel一升级，你的解析代码和库也可能要跟着改一次，嗯，强烈不推荐了。
放数据库里。爬一些商品的信息存到数据库里，然后读数据库也是很好的办法，还能熟悉一下sql的用法，面试经常问到，另外可以用数据库的事务机制来清理测试数据
在代码里动态生成。比如动态随机生成用户的姓名啊性别和年龄之类的

数据生成之后就面临着一个清理的问题。清理问题实际上数据生命周期的问题，测试数据应该有下面一些生命周期吧

短期数据。用例完了就删掉的数据，一般线上做性能测试的数据都是这样的短期数据
长期数据。用例跑出来的数据放在那里也没事，可以一直存在。这种数据太多有时候会影响测试环境的性能

自动化测试跑出的数据建议做短期数据，跑出来想办法清掉，因为自动化跑的频率其实可以很高，每次都产生一堆数据的话数据的量级可能会在短期变得很大，对测试环境的性能造成影响。

以上的一些看法是个人的浅显的粗鄙的看法，肯定有很多不成熟的地方，欢迎大家斧正。

原始封面

如何测试安全漏洞

Thu, 15 Nov 2018 02:16:58 +0800

这是2002年FreeBSD系统的一个安全漏洞。

当时一些开发人员意识到getpeername库的某个实现可能会隐藏致命的安全漏洞。

下面的代码简单的还原了漏洞的发生过程。

1 /*
2 * Illustration of code vulnerability similar to that found in
3 * FreeBSD’s implementation of getpeername()
4 */
5
6 /* Declaration of library function memcpy */
7 void *memcpy(void *dest, void *src, size_t n);
8
9 /* Kernel memory region holding user-accessible data */
10 #define KSIZE 1024
11 char kbuf[KSIZE];
12
13 /* Copy at most maxlen bytes from kernel region to user buffer */
14 int copy_from_kernel(void *user_dest, int maxlen) {
15 /* Byte count len is minimum of buffer size and maxlen */
16 int len = KSIZE < maxlen ? KSIZE : maxlen;
17 memcpy(user_dest, kbuf, len);
18 return len;
19 }

int copy_from_kernel(void *user_dest, int maxlen)方法的作用是将系统内核中的大小为maxlen的内存拷贝到用户内存里。在系统运行时，用户进程是没有权限访问系统内核的内存的，该方法等于是为用户进程开了个小后门，使得用户进程可以访问最大KSIZE大小的系统内核内存。由于系统内核内存中有很多运行时的敏感信息，所以该方法做了最大KSIZE大小内存的的限制，这是有道理的。但如果用户访问了任意大小的内核内存，那么系统敏感信息将会暴露，这将为不怀好意的攻击者提供足够多的入侵信息。

是时候为明年的面试做准备了

Sun, 11 Nov 2018 01:23:50 +0800

今年面试了不少人，也被面了很多次，多多少少有些经验是可以分享的。

之前在某个微信群里说了一下最近的互联网公司测试同学的面试套路，结果被怼，说是面试造火箭，进去以后拧螺丝，在这里分享出来，希望大家不吝赐教，错误的地方还请多多斧正。

总的来说，目前的面试更加的专业化，如果面试官的水平不错的话，面试的内容会非常有针对性，一些专业面霸的生存空间可能会进一步被压缩。

从经验上看，下面这些套路都是差不多的

业务介绍

介绍一下你所在的业务。这里主要是考察对自己的业务是否熟悉，是不是能讲清楚自己在做什么，自己什么样的角色，负责怎样的业务。
介绍一下你所在项目/产品的技术栈。对于一些前后端都有的项目来说，这个问题希望考察候选人是否了解开发在做些什么，用些什么样的技术等等。
能不能画一下你所在项目/产品的架构图。这个问题难度比较大，特别是对于从事纯客户端测试的同学来说，毕竟前后端分离的情况下，客户端测试很难了解到后台的架构情况。对于测试后台的同学来说，如果只是做单纯的功能测试的话，那么架构图也是画不出来的。这个问题其实是在考察候选人的主动学习能力和测试的深度。因为如果不是主动去了解的话，恐怕开发同学是不会跟你说明架构情况的。另外，如果测试深度足够的话，比如很深入的测试中后台系统的话，那么大致的架构情况是会毕竟清楚的。更进一步，如果你搭建过被测系统的独立性能测试环境的话，那么架构基本上是会了然于胸的了。
能不能说明一下你们目前系统/产品在架构上存在的问题。这个问题是接着上面的问题的开放性问题，主要考察候选人能不能从架构上预测到系统的问题，从而将测试工作前置，提前暴露或感知潜在的问题。对于高级别的测试同学来说，这个问题是需要提前思考答案的。

逻辑题

对于校招和初级测试同学来说，逻辑题是经常会被考察到的。逻辑题主要的考察点是解决问题的思路是不是清楚，另外这个人是不是足够的聪明灵活，毕竟很多时候，跟聪明一点的人沟通起来也相对容易一点。

逻辑题是有套路的，可以提前准备，另外就算没准备的话临场发挥也是来得及的。有时候不需要那么准确，只要思路大致能对上就可以了。

数据库题

我在面试的时候被问到过数据库的知识，但偏底层和原理，对于初中级的测试同学来说，数据库主要是考察应用,比如考察一些联表查询，group by之类的题目。对于高级别的测试同学来说，可能会问到索引，调优以及数据库引擎和集群的知识。这些也是可以提前准备的，难度不是特别大，应该是大家都能拿分的题。

linux相关的题目

我曾经面试的时候被问过linux cpu的性能指标，要求是能想到多少就列出来多少。不过对于初中级的测试同学来说，linux操作系统可能重点考察的是使用和数据处理，比如我们这里就有一道面试题是关于如何通过linux命令从log里过滤出重要信息的。当然了，在微信群中讨论的时候，有些同学说这个实在是太简单了，过滤一下导出一下就可以了，我思考了很久，还是不清楚如何在线上不通过命令做这些操作的，当然，如果log接入了类似于Elasticsearch之类的系统的话，那么不用命令也是可以的了。

编程题

是的，你没看错，确实是编程题。好在测试方向的编程题都不是很难，基本上的考察点是简单的算法，对时间和空间复杂度的理解以及基本的编程技能。另外写代码也能看出一个人是不是聪明，这里我遇到过下面几种类型的考察。

白板写算法。据说白板写可以很清楚的看出候选人的思路。
上机写代码并调试成功。这样可以远程面试以及自动计算时间和空间复杂度。
读代码找bug。读的是LRU的O(1)算法，其中有几行代码是有问题，需要找出来，其实还是有难度的。

用例设计

用例设计题是五花八门的了，这是基本功，我喜欢给一些类似于需求文档的片段让候选人根据文档写用例，总体难度不大，主要是考察阅读理解能力和用例设计能力。

总的来说，上面这些题是我遇到的比较多的类型，当然因为我经历有限水平有限，这些面试经验可能不太适用，不过很多情况下，这些面试的题目还是很有针对性的，毕竟入职之后查数据库，过滤日志，写用例，写代码做一些自动化的效率提升，这些都是日常工作的一部分，面试的时候出现相应的题目，这些也是说得通的。

综上，希望对你有所帮助。

原始封面

性能测试之前你可能需要弄明白这些事情

Thu, 08 Nov 2018 01:23:50 +0800

这应该是一个老生常谈的话题了。

之前也分享过，在做性能测试之前，对大部分同学来说，最重要的问题就是搞清楚性能测试需求。

一般来说，需求大概是下面这样子的。

给我们的系统/产品做一下性能测试。这种需求太虚了，不细化的话基本上是没有可操作性的。
测一下我们的最大在线人数。这种需求基本上是做容量，看一下项目/产品的最大容量是多少。
线上有一个问题，但是我们找不到问题的原因，希望可以压测复现一下问题，以证实一些猜想。这种需求是重现线上问题，要求脚本能够尽可能准确的模拟真实业务。

关于如何做需求分析，之前应该有分析过，这里就不重复了。很多情况下，对于测试同学来说，搞清楚性能测试的目的和需求往往是非常困难的，除了经验之外，我们还需要跟开发同学有一些共同话题，了解开发同学是怎么想的，有哪些问题是需要注意的。不过这就需要我们对开发技术有一定的了解，不然很容易跟开发之间产生信息不对称，进而开发搞开发的，我们自己测自己的，没产生合力，最终的结果应该是很难让大部分人满意的。

其实，除了需求，环境因素也非常重要。

性能测试在哪个环境测，其实很有学问。

一般来说，我们建议在跟线上环境几乎一致的独立性能测试环境去测。为什么呢？很大程度上是架构的关系。不同的架构对于测试结果的影响是巨大的。大部分情况下，我们的测试环境跟正式环境的差异还是相当明显的。测试环境可能就是单机，生产环境可能是集群，我们在单机上压出来的问题可能在集群上不会出现，另外集群上出现的问题我们在单机上可能也难以重现。

最简单省事的做法就是在正式环境上压测，不过这要注意脏数据和错误恢复的问题。我们希望在正式环境上的压测不会影响真实用户的使用，不会修改真实用户的数据，并且压出问题之后系统可以迅速恢复。

当然，大部分情况下，在正式环境做压测是相当危险的。我们一般建议在跟生产环境几乎一致的环境上做性能测试。那么这个几乎一致是什么意思呢？

架构基本一致，但可以缩容。比如线上的反向代理之后的负载均衡机器有10台，我们可能用2台就够了。
数据量基本一致。线上有100万条数据，那么我们压测的时候也用100万条左右的数据量。
数据脱敏。不要暴露用户的敏感信息。
网络条件一致。线上的带宽是1G，那么压测的时候也用同样的带宽。

那么我们定义了独立的性能测试环境之后，这个环境谁来搭建和维护呢？

我是建议测试同学自己搭建和维护。那么问题就来了，搭建测试环境的话，除了一些基本的运维操作(安装软件，修改配置)之外,我们还需要什么知识呢？

我们需要理解系统的架构。

我在面试的时候喜欢让候选人简单画一下他所测系统的架构图，另外当你在某公司进行技术晋级的时候，无论哪个技术通道，都会问所在产品的架构，可见理解架构是相当重要的。

搭建测试环境可以让我们更好的去学习系统架构。我记得之前的公司新人来了之后都会给他几天的时间去搭建一套全新的开发或者测试环境，有时候是类生产环境，搭建环境的时候，比如我们需要安装redis，那么我们可以问开发同学，redis是做什么用的，用于什么业务场景或者用于解决什么业务问题。长此以往，我们的架构理解能力一定会有所提升。

另外很多情况下，架构的演进是为了解决一些已知问题，或者是为了能够服务更多的用户，这种架构更替中的讨论和技术选型也很有蕴藏着性能测试的需求，到后门一通百通，很多事情都会得心应手了吧。

最后，基础很重要，基础好的话一些概念理解起来可能会更加顺畅。比如链路层转发进行负载均衡的方式，如果你对链路层不理解，那么这个概念理解起来就会比较的困难了。

文章很长，总而言之，大家在做性能测试之前，可能需要

分析清楚性能需求
理解系统架构
搭建测试环境
努力补充基础知识

这些是我的一些不成熟的见解，希望对大家有所帮助。

原始封面

浅谈测试环境

Thu, 18 Oct 2018 06:20:24 +0800

除了在床上，我们一天中大概最多的时间就是在测试环境上战斗和工作了。

最近在梳理测试环境和一些测试流程，在这里顺手记录一下，几年以后看过来，应该是会显得幼稚和贻笑大方的吧。

测试环境的责任边界

因为测试环境基本上是属于测试同学安身立命之本了，很多时候由于环境问题造成的漏测和事故是屡见不鲜的，因此测试环境的重要性不言而喻。

那么测试环境应该谁来管理呢？

目前看来比较好的方案是所有的测试环境都由测试同学管理，测试同学掌控发布策略，准入准出规则等等。

另外有条件的话，建议测试同学可以自行搭建测试环境。尽管很难，不过值得一试，因为这种做有如下好处

全面了解系统的架构。搭建了环境之后，你可能对数据库，服务器软件，各种中间件和一系列的配置有了一定程度的感性认识。记得我们当年新人来了之后有条件的话都会让他们搭建一下开发或者测试环境，这是熟悉系统架构的快捷方式。
了解数据源。很多时候数据源差异也会引起潜在问题。搭建测试环境的时候基本上会准备一些基础数据和小规模的业务数据，如果这些数据跟线上数据相似度高，比如有一定比例的脏数据，那么的话发现缺陷的概率相应的也会高一点把。
学习开发技能。这点不用展开了吧。
理解环境之前的差异。生产环境和测试环境之间或多或少都会有差异，这些差异其实有可能是缺陷的温床。如果我们能理解这些差异，针对这些差异做一些验证，比如线上环境有集群，而测试环境是单机，可以在集群上验证一下数据一致性的问题，这会使我们的测试用例更加的完善和高效。

综上，还是建议测试环境测试同学负责，好处还是显而易见的。卧榻之侧，岂容他人鼾睡，不是么？

准入准出规则及流程

准入准出其实跟测试环境的分层有一定的关系。不过原则上，我们可以建议在准入之前做一下简单的冒烟测试，提升准入门槛。

提升准入门槛有下面一些好处。

给开发敲警钟。很多低级问题其实都是开发质量意识低下所导致的。当然质量意识跟能力是成正比的，能力强的开发往往质量意识比较好。提升准入门槛实际上就是让大部分平均水准的开发多花点心思在功能的质量上，毕竟他们才是质量保障的源头。开发慎重一些，胜过测试点到吐血。
节约沟通成本。如果让质量很差的版本轻易的发布到测试环境，那么各种阻塞性的问题是会相当耗费沟通成本的，如果版本打回的话，大家都不开心，所以严格一点，你好我也好。

测试环境分层

有条件的话，建议可以给测试环境分层，层层隔离，每层承担不同的使命。一般来说，测试环境可以分为

开发联调测试环境。开发协作进行测试和联调的环境。这个环境可以让开发随便玩，也可以作为下一层环境的准入测试环境。
功能或模块测试环境。测试维护的某个功能或者模块的测试环境。可以直接部署分支代码。
集成测试环境。所有的功能都合入该环境进行测试，就是一般意义上的测试环境。前两个环境没有其实可以接受，但这个环境是一定需要稳定和可控的。
uat环境。可以从主干拉uat分支到该环境进行uat测试，缺陷解决后可以合回主干。
类生产环境。与生产环境尽量一致。包括代码，软硬件以及数据高度一致。正式发布之前回归策略执行的地方。
灰度环境。有条件可以有灰度环境，用来进行灰度策略的实施。
独立的性能测试环境。这种环境可能是临时的，性能测试结束之后资源可以释放掉。

一般来说，测试环境的层级越多就代表着越多的角色会参与到测试活动中去，提前发现问题的概率相对会高一点点。

测试环境与自动化

多层级的测试环境要求发布过程尽可能高度自动化。如果每次发布都很手工，都很痛苦，那么团队可能会选择维护尽可能少的测试环境来降低工作量，这显然不是我们想要的结果。
稳定的测试环境可以进行周期性的自动化回归测试。比如可以在集成测试环境跑接口或ui的自动化。

测试环境与测试及发布流程

测试环境与测试及发布流程强相关，什么样的测试环境分层从客观上会影响整体的测试开发及发布流程。

综上，每个团队不同，所采用的测试环境分层策略也不尽相同，另外作者的水平有限，上面内容仅供参考，欢迎斧正。

原始封面

使用验收标准来进行高效学习

Wed, 10 Oct 2018 06:20:24 +0800

相信大家对验收标准不是很陌生。

我们在进行测试活动的时候一般会为我们的需求加上验收标准。比如某需求要求我们实现个缺陷管理系统，那么我们可能会为这个需求分解出若干个验证标准，如可以正确的创建缺陷并分配给开发人员之类的，验收标准可以作为我们测试用例的大纲，测试用例可以来围绕验收标准展开，关注正常和异常的多种情况，从而达到保障系统质量的目的。

回到我们今天的主题——高效学习上来。

最近我也在查缺补漏，补充自己的知识，完善一下总体的认知架构。在学习过程中我发现，如果只有学习目标的话，那么学习的效率可能是不够高，或者说是学习的过程是不够聚焦的。

举个例子，比如你在学习python，你给自己定了一个小目标，半年内学会python。这个目标看起来是没有问题的，有开始和结束时间，也有着强烈的目的性。

于是你开始学习，你去网上找到了学习资料，并且看完了语法，然后搭建了python开发环境，尽管在ide和编辑器上纠结了好久，尽管对命令行执行python命令从内心深处强烈的抵触，不够好歹你可以写个hello world，然后正确运行。后来应该做什么呢？如何在工作中将python运用起来呢？你没什么头绪。过了一段时间，你又鼓起勇气，重新捡起来python，但是语法和一切都是似曾相识，但hello world运行起来已经不是那么驾轻就熟了，然后又是不知道该如何继续，再搁浅，再捡起，无限循环。

这是初学者学python的一般轨迹，相信不出意外再学习其他技能时也会陷入这样的困境。经过思考以后，我发现其实我们可以简单调整一下我们的学习方法，也许会对学习过程有一定的改进。

我们分析一下上面的例子，再上例中，我们有目标，有过程，但是却缺少一个很重要的因素，那就是学习结果的度量，也就是我们在测试活动中所说的验收标准。没有验收标准的话我们就不知道自己的学习的结果是怎么样的。比如我学完了python语法，这是一个过程，我投入了时间，经历了这些过程，但是结果如何？我学会了python语法了么？我不知道，但我知道我真的花了很多时间，其间也非常努力，我对自己的努力很满意，至于结果，没学会可能是因为我不够聪明，或者不适合学习这个吧。

真的是这样么？如果我们给学习python这个目标增加一些验收标准呢？比如最简单的验收标准：可以使用python连接数据库并自动插入一些测试数据。好了，现在我们的学习目标和验收标准是这样的了

目标：学会使用python
验收标准：可以使用python连接数据库并自动插入一些测试数据

根据目标和验收标准，我们可以重新规划学习过程

学习基本语法，先看熟，然后写一些小例子
学习python连接数据库的方法
学会python往数据库里插数据的方法
学会自动生成测试数据的方法
最后写一个脚本，完成最终功能

这样学习可能更有目的性，学习的效果也许会更好一些吧。

我们再看其他一些例子，看看如何为自己设置验收标准。

比如我要学会vuejs，那么

目标：学会vuejs
验收标准：使用vuejs写1个简单的todo list
过程分解
- 学习js语法
- 学习html/css
- 搭建vuejs开发环境
- 了解vuejs原理
- 学习vuejs的数据绑定
- 学会使用vuejs进行页面的动态渲染
- 学会使用vuejs处理相应用户输入…
- …
- …
- 最后写todo list，完成最终功能

其中上面的每个过程都可以给出更进一步的细分验收条件，比如学习html/css怎么样才算是学会呢？验收目标可以是写个简单的表单，看起来舒服就可以。

另外在这么多年的教学过程中，我发现只给学员布置作业其实是不够的。

作业可以看做是验收标准，但如果只是让同学们自己去做作业，而不去验收，或者说不去强制查看的话，那么很多人可能就因为各种原因不做作业了，没有作业的复习和巩固，很多需要大量练习的技能是很难掌握的。所以在最近的几期里，我们尝试在学院系统中为大家布置作业，然后老师批改作业，有了作业的加持，我发现一些同学的进步是非常明显的，这也验证了我的猜想，学习实际上是目标+过程+结果检查的过程。想想我们之前的学习经历，目标就是教学大纲，过程就是老师上课，结果检查和验证就是作业和考试。在我们工作之后，我们往往只注重前两点而忘记了结果的检查，这大概是导致我们自学效果不好的重要原因吧。

综上，希望对你有所帮助。

原始封面