利用fitnesse实现api接口自动化测试

奇犽

看了不少小伙伴们分享的接口测试方面的知识，仔细想想，我做接口测试也有几个年头了，大家所叙
述到的一些经验或多或少，我也曾遇到过，突然意识到知识的点滴积累是多么的重要，我记得我最早
接触接口测试的时候，就是只在浏览器里人工测试单个接口的返回结果，后来用python的unittest自
己写测试框架，和现在大多数小伙伴们的方法差不多，测试用例也是存放在excle表中，这对于单人
测试来说都还ok，但是如果是多人协同测试时，问题就出来了，因为按目录存放在不同的excle表中
的测试用例，维护起来比较麻烦，而且不便于多人查询或共同维护测试用例。所以之前的公司老大给
我们推荐了一个工具——fitnesse，它是用wiki方式在界面上管理测试用例，驱动后台脚本进行测试，
因为测试用例界面是个wiki地址，可以很方便的和大家一起协同工作，而且用例查询和维护起来都方
便的多。
      我在之前的公司用了将近一年这个工具，但是因为刚休完产假的自己工作状态非常不好，其实并
没有在这方面很尽心，只到来了新公司后，才又一次重新学习使用起这个工具来，还是api接口测试，
年前我从不同的角度分别写了几个不同的demo，虽然现在大多数用fitnesse的人都是用的slim引擎，
但是因为java helloworld水平的我一直用的python，找不到合适的支持slim的python插件，所以还是
用的fitnesse的fit引擎，用PyFIT支持起来。

     对于api接口功能测试，我个人认为需要关注的有这几个方面：接口状态，响应时间，字段格式，
返回数据，想起来之前面试阿里时，提到接口测试，他问了我很多http协议类的，具体问题记不清
了，大概是几次握手交互那类的，额，不知道是不是关注点不同的缘故，他问得几个关于接口测试的
问题我都没用过，其实到现在我还是有些疑惑的，不知道是他理解的接口测试和我理解的有偏差，不
过也许是我涉猎的领域太窄，对于接口应该怎么充分测试我是比较怀疑了，也经常会在网上翻阅关于
接口测试的文档，但是感觉收效甚微，嗯，对于未知领域的探索仍在继续，对于已知领域的小果子，
拿出来和小伙伴一起分享下吧

     所测接口：api接口，返回结果json格式

     所用工具：fitnesse，fit引擎，python

第一种方式：

   测试思想：在页面上初始化测试数据，将接口的返回结果按每个字段逐一填写期望结果，和接口
的实际结果比较

   测试数据准备：在界面上利用sql语句初始化测试数据，然后在测试用例页面included 该页面


测试用例：将json各个字段拆开填写到测试用例表格中，用ColumnFixture，测试用例格式如下

baseurl：接口基本不变的部分，这一部分可以在表格外参数化然后传值到表格里，account和pass
word是接口的两个输入参数，带？标识的是要验证的结果，将json返回结果的每个字段都拆开填写
在表格中。

后台脚本：

1. class LoginTest(ColumnFixture):
   
2.       _typeDict = {
   
3.         "description":"String",
   
4.         "BaseUrl":"String",
   
5.         "account":"String",
   
6.         "password":"String",
   
7.         "status":"Int",
   
8.         "retMsg":"String",
   
9.         "token":"String",
   
10.         "uClen":"Int",
    
11.         "uCuserId":"Int",
    
12.         "uCamount":"String",
    
13.         }
    
14. 
    
15.       def __init__(self):   
    
16.           ColumnFixture.__init__(self)
    
17.           self.account=''
    
18.           self.password=''
    
19.           self.BaseUrl=''
    
20.           self.jsonData=''
    
21.           self.ret=''      
    
22.       def getRes(self):               
    
23.           url=self.BaseUrl+"account="+self.account+"&password="+self.password
    
24.           tmp=res.fetch_res(url)   
    
25.           result = json.loads(tmp)
    
26.           return result
    
27.       def retMsg(self):
    
28.           self.jsonData=self.getRes()
    
29.           self.ret=self.jsonData["ret"]
    
30.           result=str(self.jsonData["ret"])+self.jsonData["msg"]
    
31.           return result
    
32.       def status(self):
    
33.           url=self.BaseUrl+"account="+self.account+"&password="+self.password
    
34.           result=res.fetch_status(url)
    
35.           return result   
    
36.       def token(self):
    
37.           result=''
    
38.           if self.ret==1:
    
39.               result= self.jsonData["data"]["token"]
    
40.           return result
    
41.       def uClen(self):
    
42.           result=''
    
43.           if self.ret==1:
    
44.               result=len(self.jsonData["data"]["userCapital"])
    
45.           return result
    
46.       def uCuserId(self):
    
47.           result=''
    
48.           if self.ret==1:  
    
49.               result=self.jsonData["data"]["userCapital"]["userId"]
    
50.           return result
    
51.       def uCamount(self):
    
52.           result=''
    
53.           if self.ret==1:
    
54.               result=str(self.jsonData["data"]["userCapital"]["amount"])
    
55.           return result

复制代码

优点：测试脚本结构简单，测试用例格式清晰，缺点：如果接口返回层级或字段较多时，不便于测试
用例维护，需要初始化测试数据并清除增加的数据，部分动态字段（比如creattime）无法准确校验

第二种方式：

测试思想：在已有数据库基础上，无需每次添加测试数据，在测试脚本中根据需求用sql语句检索出
对应字段的数据，作为期望结果，和接口的实际结果比较

测试数据：已有数据库基础上

测试用例：

测试脚本部分示例：

1. def retMsg(self):
   
2.             if self.status==200:
   
3.                 self.jsonData=self.getRes()
   
4.                 isUserSql="SELECT * FROM hcm_user WHERE NAME LIKE \'"+self.account+"\' AND PASSWORD LIKE \'"+self.password+ "\'AND TYPE=0"
   
5.                 self.isUser=db.queryDb(isUserSql)              
   
6.                 self.ret=self.jsonData["ret"]
   
7.                 result=str(self.jsonData["ret"])+self.jsonData["msg"]
   
8.                 return result
   
9.             else:
   
10.                 return ''
    
11.         def securityStatusCheck(self):
    
12.             symbol="="
    
13.             list=['userId','userName','emailStatus','mobileStatus','realNameAuthStatus','autoTransfer','trusteeshipAccountStatus']
    
14.             dataJson=[]
    
15.             dataCase=[]
    
16.             if self.isUser:
    
17.                 sql="SELECT a.id,a.`name`,IF(a.email!='',1,0),IF(a.`mobile`,1,0),b.`yeepay_account_status`,b.auto_transfer,b.`yeepay_account_status` FROM hcm_user a,hcm_user_auth b WHERE NAME LIKE '"+self.account+"' AND a.id=b.user_id"               
    
18.                 data=db.queryDb(sql)
    
19.                 if data:
    
20.                     for i in range (0,len(list)):
    
21.                         dataCase.append(list[i]+symbol+str(data[0][i]))
    
22.             if self.ret==1:
    
23.                 tmp=self.jsonData["data"]["securityStatus"]
    
24.                 for i in range (0,len(list)):
    
25.                     dataJson.append(list[i]+symbol+str(tmp[list[i]]))
    
26.             result=Check(dataJson, dataCase)
    
27.             return result

复制代码

测试结果：


突然发现给自己写优缺点好二啊，反正就是上面两种都没有满足老大们的要求，他们希望我能写一个
通用的框架，让没有任何编码能力的人也能进行接口测试，即只需要前台编写测试用例，不用管后台
脚本就能进行测试，于是乎有了下面第三种方式

第三种方式：

测试思想：满足老大们的要求，不用编写任何脚本即可进行接口测试

测试数据：固定初始化好的数据库

测试用例：


其中，firsturl是被依赖的登录接口，url是所测接口，blackLIst是希望过滤de返回字段的黑名单（比如
ordeId，每次都是变化的，无法准确校验，添加到黑名单中即可不对其校验），data是期望结果，因
为所测接口需要先登录然后保持session，才能返回正常结果，所以此处采用的是fit的Actionfixture

测试脚本示例：

1. from fit.Fixture import Fixture
   
2. import urllib2,cookielib,urllib
   
3. import module,json
   
4. import sys
   
5. reload(sys)
   
6. sys.setdefaultencoding('UTF-8')
   
7. 
   
8. class ActionTest(Fixture):
   
9.     _typeDict = {}
   
10. 
    
11.     def __init__(self):#初始化参数
    
12.         Fixture.__init__(self)
    
13.         self.__firstUrl  = ''   #< Private attributes (Python convention).
    
14.         self.__url = ''
    
15.         self.__parameter = ''
    
16.         self.__blackList=''
    
17.         self.__data=''
    
18.         self.res=''
    
19.         self.status=''
    
20.         self.expectedList=''
    
21.         self.actualList=''
    
22.         self.test=''
    
23. 
    
24.     _typeDict["firstUrl"] = "String"
    
25.     def firstUrl(self, s):
    
26.         self.__firstUrl = s
    
27.     _typeDict["url"] = "String"
    
28.     def url(self, s):
    
29.         self.__url = s
    
30.     _typeDict["parameter"] = "Dict"
    
31.     def parameter(self, s):
    
32.         self.__parameter = s
    
33.     _typeDict["blackList"] = "List"
    
34.     def blackList(self, s):
    
35.         self.__blackList = s
    
36.     _typeDict["data"] = "String"
    
37.     def data(self, s):
    
38.         self.__data = s
    
39.     _typeDict["do"] = "Default"      #< AUTO-DETECT: None = void
    
40.    
    
41.     def do(self):#访问接口并保存结果
    
42.         cookie=cookielib.CookieJar()
    
43.         opener=urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
    
44.         try:
    
45.             req=opener.open(self.__firstUrl)
    
46.             self.status=req.code
    
47.         except urllib2.HTTPError, e:
    
48.             self.status= e.code
    
49.         if self.status==200:
    
50.             for cj in cookie:
    
51.                 if cj.name=='JSESSIONID':
    
52.                     session= cj.value
    
53.             req=urllib2.Request(self.__url)
    
54.             data=urllib.urlencode(self.__parameter)
    
55.             try:
    
56.                 tmp = opener.open(req,data)
    
57.                 self.status=tmp.code
    
58.             except urllib2.HTTPError, e:
    
59.                 self.status=e.code
    
60.             if self.status==200:
    
61.                 self.res= tmp.read()
    
62.             else:
    
63.                 self.res='{"status":"no 200"}'
    
64.         else:
    
65.             self.res='{"loginStatus":"no 200"}'
    
66.     _typeDict["status"] = "Int"
    
67.     def status(self):
    
68.         return self.status  
    
69.     _typeDict["expect"] = "String"
    
70.     def expect(self):#调用module函数比较测试结果
    
71.         self.expectedList=[]
    
72.         self.actualList=[]
    
73.         module.resultList(self.__blackList,self.__data, self.res, self.expectedList, self.actualList)#比较后将结果存放到输出数组中
    
74.         result=module.outPut(self.expectedList)
    
75.         #tmp=unicode(self.__data, 'utf-8')
    
76.         #return str(self.actualList
    
77.         return result
    
78.     _typeDict["actual"] = "String"
    
79.     def actual(self):#调用module函数比较测试结果
    
80.         result=module.outPut(self.actualList)  
    
81.         return result
    
82. 复制代码
    
83. 测试结果：

复制代码

spartan

谢谢分享。 能介绍和Jmeter做接口测试的区别吗？

梦想家

赞一个