中高级自动化测试工程师技术栈

 

1.测试管理工具

1，TestDirector(大而全)

2，jira(简单好用)

3，Quality Center(复杂，收费)

4，禅道（简单好用）

5，bugzilla(功能简单)

6，svn(代码和文档管理工具)

7，vss类似svn

8，git，同svn，但是多分支管理比svn好

9，Note（大而全，费用太贵）

10，CQ(ClearQuest-IBM产品-大而全)

2.接口测试工具

1，Jmeter（开源）

2，postman

3，SoapUI

推荐使用 jmeter 和 postman

jmeter是一款100%纯Java编写的免费开源的工具，它主要用来做性能测试，相比loadrunner来说，它内存占用小，免费开源，轻巧方便、无需安装，越来越被大众所喜爱。

Postman是谷歌的一款接口测试插件，它使用简单，支持用例管理，支持get、post、文件上传、响应验证、变量管理、环境参数管理等功能，可以批量运行，并支持用例导出、导入。

3.性能测试工具

1，loadrunner，大而全，要学精通还是有点难度，重量级工具

2，jmeter 基于java平台的性能开源测试工具，其实也很强大，而且比较好用

3，Web bench 一个简单的web基准指标测试工具

4，Load UI，一款开源的压力测试工具，支持图形化

5，httperf 一款高性能的web性能测试工具

6，Siege 一款开源的压力和指标测试工具

7、Gatling

前两种是比较常用的

4.C/S自动化工具

1，qtp (录制回放和脚本编辑)，用到的是vb语言

2，winrunner IBM产品类似qtp

3，autoit 在窗口定位上做到很不错

5.白盒测试工具

1，jtest java语言的单元测试框架

2，JUnit 验证java的工具

3，cppunit 跨平台的c++单元测试框架

4，gtest 跨平台的c++单元测试框架

5，PhpUnit Php

6，BoundsChecker C++,Delphi API和OLE错误检查、指针和泄露错误检查、内存错误检查

7，TrueTime C++,Java,Visual Basic 代码运行效率检查、组件性能的分析

6.代码扫描工具

1，Coverity源代码静态分析工具

2，cppcheck c++静态扫描工具

3，gcover代码覆盖率工具

4，findbugs：基于字节码分析，大量使用数据流分析技术，侧重运行时错误检测，如空指针引用等

5，SonarLint

6，TscanCode

7持续集成工具

1，jenkins

2，Hudson

8.网络测试工具

1，思博伦 目前流行的一款网络自动化测试商用平台了(而且能够完全顶替loadrunner)，基本上能够满足所有的网络产品测试需求了，不过很贵

2，Ixia，也是对网络设备进行性能和压力测试工的平台

3，wireshark 数据包抓取分析和回放测试工具

4，tc 网络丢包和试验模拟工具，非常好用

5，iperf 用来测试tcp和udp的网络质量

6，tcpping工具工作在 TCP 层，通过发送伪造的 TCP SYN 包并侦听来自服务器或中间设备返回的 SYN/ACK 或 RST

9.app自动化工具

1，appium 这个应该算是目前最流行的基于app的自动化测试框架了

2，instruments ios平台下的自动化测试框架，用java语言写的

3，uiautomator安卓自动化测试框架，基本上支持安卓的所有事件操作

4，Monkey 安卓自带的测试工具

5，Monkey Runner Monkey改进版，支持自己编写脚本测试，用Python语言

6，Robotium 一款国外的Android自动化测试框架，用法比较简单

10.web安全测试工具

金融服务和银行业一直是安全漏洞的受害者，因为会破坏了大量敏感的用户数据。然而，金融服务是每个人的必备品。所以在这里我们列出了一些安全测试工具，用于构建一个健壮的应用程序。

1，appscan，算是用的非常多的一款工具了，扫描后能够将绝大部分的漏洞找出来。

2，Netsparker Community Edition 这个程序可以检测SQL注入和跨页脚本事件。牛逼的是还能提供解决方案

3，Websecurify 这是个简单易用的开源工具，此程序还有一些人插件支持，可以自动检测网页漏洞。运行后可生成多种格式的检测报告

4，Wapiti 这是一个用Python编写的开源的工具，可以检测网页应用程序，探测网页中存在的注入点。

5，N-Stalker Free Version 此工具可一次检测100个以上的页面，包括跨页脚本的检测。

6，skipfish 这是一个轻量级的安全测试工具，处理速度很快，每秒可处理2000个请求。

7，Scrawlr HP的一款免费软件，可检测SQL注入漏洞。

8，Watcher: 这个是Fiddler的插件，可在后台静默运行，可检测跨域提交等。。

9，WebScarab 这个实际上是一个代理软件，有很多功能，可以检测XSS跨站脚本漏洞、SQL注入漏洞等。。

10，抓包工具:fiddler

11、burpsuite：暴力破解、抓包工具

理论部分

1.测试分为哪几个阶段

2.测试的流程是什么

3.如何做好测试计划

4.常见的测试用例设计方法有哪些

5.一条bug记录包含哪些内容

 5.如何分层自动化测试

6.如何保证脚本的有效性

7.如何降低自动化维护成本

8.常见的测试覆盖类型

9.B/S和C/S架构什么区别

，客户端，比如微信，QQ

，浏览器页面，比如百度页面

10.安全性都包含哪些内容

11.测试报告都包含哪些内容

12.Alpha和Beta测试的区别是什么

13.bug的类型都有哪些

 

Python部分

1.面向对象的概念

代码示例：

 1 # Animal是类,相同事物的统称
 2 class Animal(object):
 3     def run(self):
 4         print('Animal is running...')
 5 
 6 
 7 # Dog类,继承于Animal类
 8 class Dog(Animal):
 9     pass
10 
11 puppy = Dog()
12 puppy.run()
13 
14 # 多态,子类方法覆盖父类方法
15 class Cat(Animal):
16     def __init__(self, name):
17         # __name是属性
18         self.__name = name
19 
20     def getName(self):
21         print(self.__name)
22 
23     def run(self):
24         print('Cat is running...')
25 
26 
27 # limi是一个猫类的实例
28 limi = Cat("limi")
29 # run是实例的一个方法
30 limi.run()
31 # getName方法
32 limi.getName()

2.什么是进程，线程，协程

代码示例：

 1 # encoding: utf-8
 2 #进程
 3 # from multiprocessing import Process
 4 #
 5 # def foo(i):
 6 #     print("This is Process ", i)
 7 #
 8 # for i in range(5):
 9 #     p = Process(target=foo, args=(i,))
10 #     p.start()
11 
12 #线程
13 # import threading
14 #
15 # def show(i):
16 #     print('This is Thread', i)
17 #
18 # for i in range(5):
19 #     t = threading.Thread(target=show, args=(i,))
20 #     t.start()
21 
22 #协程
23 import gevent
24 
25 def foo():
26     print("start_foo")
27     gevent.sleep(2)
28     print("end_foo")
29 
30 def bar():
31     print("start_bar")
32     gevent.sleep(0)
33     print("end_bar")
34 
35 # foo()
36 # bar()
37 gevent.joinall([
38     gevent.spawn(foo),
39     gevent.spawn(bar),
40 ])

 3.如何使用python实现socket编程

 1 #encoding: utf-8
 2 #服务端
 3 
 4 # 导入 socket 模块
 5 import socket
 6 
 7 # 创建 socket 对象
 8 s = socket.socket()
 9 # 绑定端口
10 s.bind(("127.0.0.1", 6666))
11 
12 # 等待客户端连接
13 s.listen(5)
14 
15 while True:
16     # 建立客户端连接
17     c, addr = s.accept()
18     print '连接地址：', addr
19     c.send('Welcome')
20     # 关闭连接
21     c.close()

 1 #encoding: utf-8
 2 客户端
 3 # 导入 socket 模块
 4 import socket
 5 
 6 # 创建 socket 对象
 7 s = socket.socket()
 8 
 9 #连接服务端
10 s.connect(("127.0.0.1", 6666))
11 print s.recv(1024)
12 s.close()

4.什么是lambda函数

 1 #encoding: utf-8
 2 
 3 #计算平方
 4 def square(x):
 5     return x**2
 6 
 7 print square(10)
 8 
 9 
10 #lambda表达式
11 r = lambda x:x**2
12 print r(10)

5.tuple和list有什么区别

6.range()函数的用法

1 #range生成从0到100的列表
2 alist = range(0, 101)
3 print(alist)
4 
5 #设置步长为2
6 blist = range(2, 101, 2)
7 print(blist)

7.字符串的拆分方法有哪些

8.单引号，双引号，三引号的区别

9.*args，**kwargs有什么作用

 1 #encoding: utf-8
 2 
 3 #arg
 4 def test_args(first, *args):
 5    print first
 6    for v in args:
 7       print "args %s" % v
 8 
 9 #args = (2, 3, 4, 5)
10 test_args(1, 2, 3, 4, 5, 6)
11 
12 #kwargs
13 def test_kwargs(first, *args, **kwargs):
14    print first
15    for v in args:
16       print "args %s" % v
17    for k, v in kwargs.items():
18       print "kwargs", (k, v)
19 #args = (2, 3, 4, 5)
20 #kwargs: k1=5, k2=6, k0=4
21 test_kwargs(1, 2, 3, 4, 5, k0=4, k1=5, k2=6)

10.python中pass语句的作用

1 #encoding: utf-8
2 
3 def test():
4     pass
5 
6 test()

11.re模块中match和search方法的不同

 1 #encoding: utf-8
 2 import re
 3 
 4 s1 = "helloworld, helloworld"
 5 w1 = 'hello'
 6 w2 = 'world'
 7 
 8 #search扫描整个字符串
 9 print(re.search(w2, s1))
10 print(re.search(w2, s1).group())
11 
12 #match只在字符串开始的位置匹配
13 print(re.match(w2, s1))
14 print(re.match(w2, s1).group())

12.WSGI和FastCGI的的关系

13.python是如何操作文件的

 1 #encoding: utf-8
 2 
 3 #写文件
 4 f = open('test.txt', 'wt')
 5 f.write("hello world")
 6 f.close()
 7 
 8 #使用with，追加内容，不用关心文件关闭问题
 9 with open("test.txt", 'at') as f:
10     f.write("\nhello mook")
11 
12 #读取文件
13 with open("test.txt", 'rt') as f:
14     print(f.read())

14.python的内存管理机制

 1 #encoding: utf-8
 2 from sys import getrefcount
 3 
 4 #引用计数
 5 a1 = 10000000
 6 a2 = 10000000
 7 #del a1
 8 del a2
 9 
10 print(id(a1))
11 #print(id(a2))
12 
13 #检验a1和a2是同一个东西
14 #print(a1 is a2)
15 
16 # #获取a2的引用计数
17 print(getrefcount(a1))

15.dict的items与iteritems的区别

 1 #encoding: utf-8
 2 
 3 testl = {'key1': 2, 'key2': 3, 'key3': 4}
 4 
 5 kv1 = testl.items()
 6 # print(next(kv1))
 7 
 8 kv2 = testl.iteritems()
 9 print(next(kv2))
10 print(next(kv2))
11 print(next(kv2)) 

16.python常用算法

sorted()方法排序后生成新的列表，不会改变原来的列表

list.sort()方法排序后会改变原来的列表

1 #encoding: utf-8
2 
3 alist = [0, 10, 88, 19, 9, 1]
4 #print(sorted(alist))
5 
6 #print(sorted(alist, reverse=True))
7 
8 alist.sort(reverse=True)
9 print(alist)

冒泡排序：

 1 #encoding: utf-8
 2 
 3 # 冒泡排序
 4 def bubble_sort(lists):
 5     #获取数组长度
 6     count = len(lists)-1
 7     itemrange = range(count, 0, -1)
 8     #N个元素遍历N次
 9     for index in itemrange:
10         #第i个和第i+1个依次对比
11         for sub_index in range(index):
12             #大的元素冒上去
13             if lists[sub_index] > lists[sub_index+1]:
14                 lists[sub_index],lists[sub_index+1]=lists[sub_index+1],lists[sub_index]
15     return lists
16 
17 alist = [0, 10, 88, 19, 9, 1]
18 print(bubble_sort(alist))

快速排序：

 1 #encoding: utf-8
 2 # 快速排序
 3 def quick_sort(lists, left, right):
 4     #递归过程中，发现left和right一致时，停止递归，直接返回列表
 5     if left >= right:
 6         return lists
 7     #定义游标
 8     low = left
 9     high = right
10 
11     #取参考标志，最左边的元素
12     key = lists[low]
13     while low < high:
14         #从最右侧向左，依次和标志元素对比，如果右侧的元素大于标志元素
15         while low < high and lists[high] >= key:
16             #右侧减1
17             high -= 1
18         #否则low赋high值
19         lists[low] = lists[high]
20 
21         #从最左侧向右，依次和标志元素对比，如果左侧的元素小于标志元素
22         while low < high and lists[low] <= key:
23             #左侧加1
24             low += 1
25         #否则high赋low值
26         lists[high] = lists[low]
27 
28     #最后给high位置赋值
29     lists[high] = key
30 
31     #处理左侧元素
32     quick_sort(lists, left, low - 1)
33     #处理右侧元素
34     quick_sort(lists, low + 1, right)
35     return lists
36 
37 alist = [0, 10, 88, 19, 9, 1, 7]
38 print(quick_sort(alist, 0, 6))

堆排序：

 1 #encoding: utf-8
 2 
 3 def heap_sort(lst):
 4     def sift_down(start, end):
 5         """最大堆调整"""
 6         root = start
 7         print "root %d start %d end %d"%(root, start, end)
 8         while True:
 9             child = 2 * root + 1
10             #print "child index: %d" % child
11 
12             #终止条件，孩子的索引值超过数组最大长度
13             if child > end:
14                 break
15             #print "lst child value:%d" % lst[child]
16 
17             #确定最大的孩子节点的索引值
18             if child + 1 <= end and lst[child] < lst[child + 1]:
19                 child += 1
20                 #print "child+1 index: %d" % child
21 
22             #孩子节点最大值和根节点交换
23             if lst[root] < lst[child]:
24                 lst[root], lst[child] = lst[child], lst[root]
25                 #print "lstroot %d" % lst[root], "lstchild %d" % lst[child]
26                 root = child
27                 #print "root %d" % root
28             else:
29                 break
30 
31     print("-----------------创建最大堆------------------")
32     # 创建最大堆
33     print(xrange((len(lst) - 2) // 2, -1, -1))
34     for start in xrange((len(lst) - 2) // 2, -1, -1):
35         print "---->Loop start %d" % start
36         sift_down(start, len(lst) - 1)
37         print(lst)
38 
39     print("-----------------排序过程------------------")
40     # 堆排序
41     for end in xrange(len(lst) - 1, 0, -1):
42         #首尾交换
43         lst[0], lst[end] = lst[end], lst[0]
44         #剩余重新堆排序
45         sift_down(0, end - 1)
46         print(lst)
47     return lst
48 
49 
50 alist = [70, 60, 12, 40, 30, 8, 10]
51 print(heap_sort(alist))

二分查找：

 1 # encoding: utf-8
 2 
 3 alist = [0, 1, 10, 88, 19, 9, 1]
 4 
 5 
 6 def binary_search(arr, start, end, hkey):
 7     if start > end:
 8         return -1
 9     mid = start + (end - start) / 2
10     if arr[mid] > hkey:
11         return binary_search(arr, start, mid - 1, hkey)
12     if arr[mid] < hkey:
13         return binary_search(arr, mid + 1, end, hkey)
14     return mid
15 
16 
17 alist = sorted(alist)
18 print(alist)
19 print binary_search(alist, 0, 6, 9)

素数（质数）：

 1 #encoding: utf-8
 2 
 3 #0,1不是素数
 4 #除了1和它自身外，不能被其他自然数整除的数
 5 def is_prime(n):
 6     if n <= 1:
 7         return False
 8 
 9     for i in range(2, n-1):
10         if n % i == 0:
11             return False
12     return True
13 
14 for i in range(0, 100):
15     if is_prime(i):
16         print i

 

Linux部分

基础命令

网络命令：

系统命令：

 

计算机网络相关

1.OSI网络七层模型指的哪些内容

2.http协议中get，post的区别

2.tcp和udp的区别

3.tcp连接3次握手的具体过程

tcp连接4次挥手的过程（主动方可以是客户端，也可以是服务端）

4.socket建立连接的过程

 

操作系统相关

1.进程与线程的区别

2.进程都有哪些状态

3.进程同步与互斥的区别

4.进程间通信都包括哪些

5.进程的调度算法有哪些

6.死锁产生的原因

7.页面置换算法都有哪些

8.makefile的作用是什么

9.什么是虚存，实存，共享内存

 

MySQL相关

1.创建数据库：CREATE DATABASE 数据库名；

2.删除数据库：DROP  DATABASE 数据库名；

3.创建数据表：CREATE TABLE 表名；

4.插入数据：INSERT INTO 表名 VALUES（内容）；

5.查询数据：SELECT 字段名 FROM 表名 WHERE 条件；

6.更新数据：UPDATE 表名 SET 字段名=新值 WHERE 条件；

7.删除数据表：DROP TABLE 表名；

 

Fiddler工具相关

 

1.如何抓取手机包

具体使用过程，可以参考自己之前的博客：http://www.cnblogs.com/ailiailan/p/hanxiaobei.html

2.实现慢网速，过滤

过滤：

慢网速：

自定义修改延时时间：

 

Android相关

1.Android的四大组件

2.Activity的生命周期

Activity的4个状态：运行、暂停、停止、关闭；关闭有系统来完成。

4个状态间的转换过程图：

3.什么是ANR

ANR：应用无响应，是由系统来监控应用程序的，如果应用程序超时，系统会弹出ANR提示

4.Android常见的5种布局

5.Android中动画类型有哪几种

 

ADB相关

1.重启adb服务

2.app的安装与卸载

3.电脑和手机之间传输数据

4.如何静默安装app

5.adb命令启停一个app

-S：如果app已经启动了，先执行停止app，再启动

6.通过关键字查找已安装的包

-f：所有包              -3：第三方包               -i：已经安装的包

7.截屏、录屏

8.抓log

9.获取当前CPU，内存状态

 

Monkey相关

1.Monkey进行压力测试的命令

 2.如何重现crash，anr

3.如何提取crash，anr信息

adb shell monkey -v -v -v -p packagename count >文件名.txt  （3个-v会显示最详细的log信息）

4.如何设置monkey运行8个小时

--throttle 毫秒数     （定义两个动作之间的时间间隔）   时间间隔 * count = 总执行时间

5.在crash/anr出现后，如何继续执行

 6.monkey执行指定的事件类型

 

自动化工具

1.Instrumentation的原理是什么

2.Instrumentation用来测试什么

3.什么时候用Instrumentation

4.UIAutomator是什么

5.UIAutomator可以测试什么

6.如何识别App视图内的元素

7.Selendroid原理

8.Robotium原理

9.Appium的理念是什么

10.Appium相关概念

11.Appium的环境

12.Appium初始化需要配置哪些内容

13.Appium测试Native App的原理

14.Appium测试Hybrid App的原理

15.Appium测试Ios App的原理

16.Native App元素的定位工具

17.定位元素的Api有哪些

18.Native App脚本的编写原则

19.Native App初始化注意事项

20.Hybrid App的定位方式

21.Hybrid App脚本的编写原则

 22.Hybrid App初始化注意事项

 

 

自动化框架

1.unittest框架都包含哪些内容

TestFixture包含

2.什么是数据驱动

3.数据驱动DDT的原理

4.数据驱动DDT的意义

5.什么是行为驱动

6.行为驱动Lettuce的原理是什么

代码示例：

自动化测试代码：

 1 #encoding:utf-8
 2 from lettuce import *
 3 from appium import webdriver
 4 
 5 @before.each_scenario
 6 def lauchApp(scenario):
 7     desired_caps = {}
 8     desired_caps['platformName'] = 'Android'
 9     desired_caps['platformVersion'] = '5.1'
10     desired_caps['deviceName'] = '192.168.56.102:5555'
11     desired_caps['appPackage'] = 'com.android.calculator2'
12     desired_caps['appActivity'] = '.Calculator'
13     desired_caps["unicodeKeyboard"] = "True"
14     desired_caps["resetKeyboard"] = "True"
15     world.driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)
16 
17 @after.each_scenario
18 def closeApp(scenario):
19     world.driver.quit()
20 
21 @step("I have two number: (\d+) and (\d+)")
22 def have2number(step, number1, number2):
23     world.number1 = number1
24     world.number2 = number2
25 
26 @step("Do add method")
27 def doAdd(step):
28     numa = world.driver.find_element_by_id("digit_"+world.number1)
29     numa.click()
30 
31     add = world.driver.find_element_by_id("op_add")
32     add.click()
33 
34     numb = world.driver.find_element_by_id("digit_"+world.number2)
35     numb.click()
36 
37     equal =  world.driver.find_element_by_id("eq")
38     equal.click()
39 
40     world.result = world.driver.find_element_by_class_name("android.widget.EditText").text
41 
42 @step("I get result: (\d+)")
43 def judgeResult(step, result):
44     assert result == world.result, "The result are not equal %s and %s" %result and world.result

测试用例：

 1 Feature: Calculation
 2     Input two number, then compare result
 3 
 4     Scenario: Do a simple add method
 5         Given I have two number: 1 and 5
 6         When Do add method
 7         Then I get result: 6
 8 
 9     Scenario: Do a simple add method
10         Given I have two number: 2 and 5
11         When Do add method
12         Then I get result: 8

7.什么是关键字驱动

8.关键字驱动测试框架Robot framework的原理

RIDE工具：

9.测试报告管理

代码示例：

 1 #encoding: utf-8
 2 import unittest
 3 import time
 4 from HTMLTestRunner import HTMLTestRunner
 5 
 6 class MyTestCase(unittest.TestCase):
 7     #每条用例初始化
 8     def setUp(self):
 9         self.initdata = "hello imooc"
10     #测试用例，以test开头
11     def test_something(self):
12         self.assertEqual("hello imooc", self.initdata)
13     #每条用例执行完后释放资源
14     def tearDown(self):
15         pass
16 
17 if __name__ == '__main__':
18     #声明一个suite
19     suite = unittest.TestSuite()
20     #从类加载用例集
21     cases = unittest.TestLoader().loadTestsFromTestCase(MyTestCase)
22     #添加用例到suite
23     suite.addTests(cases)
24 
25     #生成HTMLTestReport
26     #以时间戳来定义报告名称
27     now = time.strftime("%Y-%m-%d-%H_%M_%S", time.localtime(time.time()))
28     HtmlFile = "report/" + now + "_Report.html"
29     fp = file(HtmlFile, "wb")
30 
31     #声明一个runner
32     myTestRunner = HTMLTestRunner(stream=fp, title=u"测试报告", description=u"用例测试情况")
33 
34     #执行Runner
35     myTestRunner.run(suite)
36     fp.close()

10.邮件通知

代码示例：

#!/usr/bin/python
# -*- coding: utf8 -*-
import smtplib
from email.mime.text import MIMEText

mail_host = "smtp.163.com"  # 设置服务器
mail_user = "[email protected]"  # 用户名
mail_pass = "tester123"  # 口令
mail_postfix = "163.com"  # 发件箱的后缀

# to_list：收件人；sub：主题；content：邮件内容
def send_mail(to_list, sub, reportpath):
    file = open(reportpath, "rb")
    content = ""
    for line in file.readlines():
        content = content + line.replace("class='hiddenRow'", "")

    # 这里的hello可以任意设置，收到信后，将按照设置显示
    me = "TestCenter" + "<" + mail_user + ">"
    # 创建一个实例，这里设置为html格式邮件
    msg = MIMEText(content, _subtype='html', _charset='utf-8')
    # 设置主题
    msg['Subject'] = sub
    msg['From'] = me
    msg['To'] = ";".join(to_list)
    try:
        s = smtplib.SMTP()
        # 连接smtp服务器
        s.connect(mail_host)
        # 登陆服务器
        s.login(mail_user, mail_pass)
        # 发送邮件
        s.sendmail(me, to_list, msg.as_string())
        s.close()
        return True
    except Exception, e:
        return False

 

接口测试相关

1.Fiddler抓取https包

2.如何实现一个Api测试框架

3.如何使用Python requests实现get请求

代码示例：

 1 #encoding: utf-8
 2 
 3 import requests
 4 import unittest
 5 import ddt
 6 
 7 @ddt.ddt
 8 class testClass(unittest.TestCase):
 9 
10     @ddt.data("App专项测试", "自动化", "Python")
11     def testGet(self, queryword):
12         #header部分的配置
13         headers_data = {
14             'User-Agent':'Mozilla/5.0 (Linux; Android 5.1.1; Nexus 6 Build/LYZ28E) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Mobile Safari/537.36',
15             'Host':'m.imooc.com',
16             'Referer': 'https://m.imooc.com/',
17             'Connection':'keep-alive',
18             'Accept-Encoding':'gzip, deflate, br'
19         }
20 
21         #cookies部分的配置
22         cookies_data = dict(imooc_uuid='ffbd103a-b800-4170-a267-4ea3b301ff06',
23                             imooc_isnew_ct='1511175583',
24                             imooc_isnew='2',
25                             page = 'https://m.imooc.com/')
26 
27         #get请求的构造
28         res = requests.get(
29             "https://m.imooc.com/search/?words="+queryword,
30             headers=headers_data,
31             cookies=cookies_data)
32 
33         #print res.status_code
34         #print res.text
35 
36         self.assertTrue(u"共找到" in res.text)
37 
38 if __name__ == "__main__":
39     unittest.main()

4.如何使用Python requests实现post请求

代码示例：

 1 #encoding: utf-8
 2 import requests
 3 import unittest
 4 import ddt
 5 
 6 @ddt.ddt
 7 class testClass(unittest.TestCase):
 8 
 9     @ddt.data(
10         ("15977778888", "999999"),
11         ("15977778889", "999998")
12     )
13     @ddt.unpack
14     def testPost(self, username_data, password_data):
15         formdata = {
16             "username": username_data,
17             "password": password_data,
18             "verify": '',
19             "referer":'https://m.imooc.com'}
20 
21         headers_data = {
22             'User-Agent': 'Mozilla/5.0 (Linux; Android 5.1.1; Nexus 6 Build/LYZ28E) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Mobile Safari/537.36',
23             'Host': 'm.imooc.com'
24         }
25 
26         #cookies部分的配置
27         cookies_data = dict(imooc_uuid='ffbd103a-b800-4170-a267-4ea3b301ff06',
28                             imooc_isnew_ct='1511175583',
29                             imooc_isnew='2',
30                             page = 'https://m.imooc.com/')
31 
32         res = requests.post("https://m.imooc.com/passport/user/login",
33             data = formdata,
34             headers = headers_data,
35             cookies = cookies_data
36         )
37 
38         print res.json()
39 
40         self.assertTrue(90003 == res.json()['status'] or 10005 == res.json()['status'])
41 
42 if __name__ == "__main__":
43     unittest.main()

5.什么是持续集成

6.持续集成都包括哪些内容

7.持续集成有什么意义

8.实现持续集成的工具有哪些

9.如何搭建Jenkins持续集成平台

10.使用Jenkins需要做哪些配置

11.持续集成的应用

 

服务端测试

1.服务端压力测试需要关注哪些指标

 

兼容性测试

1.App兼容性测试都考虑哪些因素

可以借助云测平台，提高兼容性测试的覆盖度

 

2.WAP网页兼容性测试都考虑哪些因素

3.PC网页兼容性测试都考虑哪些因素

 

Bug 调试与定位

1.APP相关的bug调试工具有哪些

2.WAP网页相关的bug调试工具有哪些

3.PC网页相关的bug调试工具有哪些

 

 

 

转载于:https://www.cnblogs.com/tester-l/p/9482397.html