autotest / api_demo · Commits

Commit 57fd14e1de4c238ace43aed43a97a2f85e822b38

Authored by SuperPC
Committed by liujiqiang
1 parent 8f3f2bcf

删除冗余的代码和注释

Inline Side-by-side
Showing 4 changed files with 578 additions and 903 deletions
src/commons/ConfigDB.py
  View file @57fd14e
1 -#!/usr/bin/python  
2 -# -*- coding: UTF-8 -*-  
3 -import MySQLdb  
4 -import commons.common as ca  
5 -import json  
6 -from commons.Logging import Logger  
7 -# import chardet  
8 -log=Logger()  
9 -  
10 -  
11 -dbhost=ca.get_global_config('global_data','Database','dbhost')  
12 -dbport=ca.get_global_config('global_data','Database','dbport')  
13 -dbname=ca.get_global_config('global_data','Database','dbname')  
14 -dbuser=ca.get_global_config('global_data','Database','dbuser')  
15 -dbpassword=ca.get_global_config('global_data','Database','dbpassword')  
16 -#dbcharset=get_global_config('Database','dbcharset')  
17 -  
18 -def mysql_selectOne(select_action):  
19 - action=select_action  
20 - db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )  
21 - cursor = db.cursor()  
22 - # 使用cursor()方法获取操作游标  
23 - try:  
24 - # 使用execute方法执行SQL语句  
25 - cursor.execute(action)  
26 - # 使用 fetchone() 方法获取一条数据  
27 - data = cursor.fetchone()  
28 -# print data  
29 - return data  
30 - except Exception as e:  
31 - print("数据库操作异常：%s" % str(e))  
32 - log.error("数据库操作异常：%s" % str(e))  
33 - assert False  
34 - finally:  
35 - # 关闭数据库连接  
36 - db.close()  
37 -  
38 -def mysql_selectAll(select_action):  
39 - action=select_action 1 +#!/usr/bin/python
  2 +# -*- coding: UTF-8 -*-
  3 +import MySQLdb
  4 +import commons.common as ca
  5 +import json
  6 +from commons.Logging import Logger
  7 +# import chardet
  8 +log=Logger()
  9 +
  10 +
  11 +dbhost=ca.get_global_config('global_data','Database','dbhost')
  12 +dbport=ca.get_global_config('global_data','Database','dbport')
  13 +dbname=ca.get_global_config('global_data','Database','dbname')
  14 +dbuser=ca.get_global_config('global_data','Database','dbuser')
  15 +dbpassword=ca.get_global_config('global_data','Database','dbpassword')
  16 +#dbcharset=get_global_config('Database','dbcharset')
  17 +
  18 +def mysql_selectOne(select_action):
  19 + action=select_action
40 db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' ) 20 db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )
41 - #游标加上cursorclass=MySQLdb.cursors.DictCursor后，返回值会变成字典，不加时返回数据格式如：(("001","test"),)加了后变成({'name': test, 'id': 001L,})  
42 - #cursor = db.cursor(cursorclass=MySQLdb.cursors.DictCursor)  
43 cursor = db.cursor() 21 cursor = db.cursor()
44 - # 使用cursor()方法获取操作游标  
45 - try:  
46 - # 使用execute方法执行SQL语句  
47 - cursor.execute(action)  
48 - # 使用 fetchall() 方法获取所有数据  
49 - data = cursor.fetchall()  
50 -# print data  
51 - return data  
52 - except Exception as e:  
53 - print("数据库操作异常：%s" % str(e))  
54 - log.error("数据库操作异常：%s" % str(e))  
55 - assert False  
56 - finally:  
57 - # 关闭数据库连接  
58 - db.close()  
59 -  
60 -def mysql_delete(delete_action):  
61 - action=delete_action  
62 - db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )  
63 - cursor = db.cursor()  
64 - # 使用cursor()方法获取操作游标  
65 - try:  
66 - # 使用execute方法执行SQL语句  
67 - cursor.execute(action)  
68 - # 提交  
69 - db.commit()  
70 - except Exception as e:  
71 - print("数据库操作异常：%s" % str(e))  
72 - log.error("数据库操作异常：%s" % str(e))  
73 - # 错误回滚  
74 - db.rollback()  
75 - finally:  
76 - # 关闭数据库连接  
77 - db.close()  
78 -  
79 -def mysql_update(update_action):  
80 - action=update_action  
81 - db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )  
82 - cursor = db.cursor()  
83 - # 使用cursor()方法获取操作游标  
84 - try:  
85 - # 使用execute方法执行SQL语句  
86 - cursor.execute(action)  
87 - # 提交  
88 - db.commit()  
89 - except Exception as e:  
90 - print("数据库操作异常：%s" % str(e))  
91 - log.error("数据库操作异常：%s" % str(e))  
92 - # 错误回滚  
93 - db.rollback()  
94 - finally:  
95 - # 关闭数据库连接  
96 - db.close()  
97 -  
98 -def mysql_insert(insert_action):  
99 - action=insert_action  
100 - db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )  
101 - cursor = db.cursor()  
102 - # 使用cursor()方法获取操作游标  
103 - try:  
104 - # 使用execute方法执行SQL语句  
105 - cursor.execute(action)  
106 - # 提交  
107 - db.commit()  
108 - except Exception as e:  
109 - print("数据库操作异常：%s" % str(e))  
110 - log.error("数据库操作异常：%s" % str(e))  
111 - # 错误回滚  
112 - db.rollback()  
113 - finally:  
114 - # 关闭数据库连接  
115 - db.close()  
116 -  
117 -def mysql_check_insert(api,section,check_sql,delete_sql,insert_sql):  
118 - log.info(u"======测试数据准备======")  
119 - check=ca.get_api_config(api, section, check_sql)  
120 - delete=ca.get_api_config(api, section, delete_sql)  
121 - insert=ca.get_api_config(api, section, insert_sql)  
122 -# print check  
123 -# print delete  
124 -# print insert  
125 - try:  
126 - db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )  
127 - cursor = db.cursor()  
128 - # 使用cursor()方法获取操作游标  
129 - # 使用execute方法执行SQL语句  
130 - cursor.execute(check)  
131 - result=cursor.fetchall()  
132 - # 提交  
133 - db.commit()  
134 - if result:  
135 - log.info(u"检查到数据库有重复数据%r"%str(result))  
136 - log.info(u"删除查询到的重复数据%r"%str(delete))  
137 - cursor.execute(delete)  
138 - log.info(u"删除数据完成")  
139 - log.info(u"向数据库中插入测试数据%r"%str(insert))  
140 - cursor.execute(insert)  
141 - log.info(u"插入数据完成")  
142 - result=cursor.fetchall()  
143 - db.commit()  
144 - return result  
145 - else:  
146 - log.info(u"数据库没有重复数据直接插入自定义数据%r"%str(insert))  
147 - result=cursor.execute(insert)  
148 - log.info(u"插入数据完成，返回结果为为%r"%str(result))  
149 -# cursor.fetchall()  
150 - db.commit()  
151 - return result  
152 -  
153 - except Exception as e:  
154 - print(u"数据库操作异常：%r" % str(e))  
155 - log.error(u"数据库操作异常：%r" % str(e))  
156 - # 错误回滚  
157 - db.rollback()  
158 - assert False  
159 - finally:  
160 - # 关闭数据库连接  
161 - db.close()  
162 -  
163 -  
164 -  
165 -def mysql_select_order(orderNum):  
166 - return mysql_selectOne("SELECT * FROM `order`.orders WHERE code = '%s';"%orderNum)  
167 -  
168 -def mysql_delete_order(orderNum):  
169 - mysql_delete("DELETE FROM `order`.orders WHERE code = '%s';"%orderNum)  
170 -  
171 -def mysql_select_coupon(couponNum):  
172 - return mysql_selectOne("SELECT * FROM `customer`.customer_coupon WHERE id = '%s';"%couponNum)  
173 -  
174 -def mysql_delete_coupon(couponNum):  
175 - mysql_delete("DELETE FROM `customer`.customer_coupon WHERE id = '%s';"%couponNum)  
176 -  
177 -  
178 -def Check_in_Mysql(in_data,sql_spm):  
179 - log.info(u"======从数据库中查询传入数据======")  
180 - result=mysql_selectAll(sql_spm)  
181 - log.info(u"传入in_data为: %s"%in_data)  
182 - log.info(u"数据库查询到的结果为 %s"%result)  
183 -  
184 - result=str(result)  
185 -# print "1111111",result.decode("utf-8")  
186 - if len(str(in_data)) == 0 and len(result)!=0:  
187 - log.error(u"传入数据为空!!\n")  
188 - assert False  
189 - return  
190 - elif len(str(in_data)) == 0 and len(result)==0:  
191 - log.error(u"传入数据与数据库查询结果都为空!!\n")  
192 - assert False  
193 - return  
194 - elif len(str(in_data)) != 0 and len(result)==0:  
195 - log.error(u"数据库查询结果为空\n")  
196 - assert False  
197 - return  
198 - elif isinstance(in_data,(list)):  
199 - log.info(u'检查的数据格式 为list类型')  
200 - for i in range(0,len(in_data)):  
201 - #由于数据库查询的数据中，中文的格式为unicode-escape，所以传入的数据需要进行encode  
202 - in_data[i]=str(in_data[i]).decode("utf-8").encode("unicode-escape")  
203 -# log.info(u"正在检查输入数据:%s"%in_data[i])  
204 - if in_data[i] in result:  
205 - assert True  
206 - log.info(u"遍历list第%d次,插入数据%r与数据库查询结果一致"%(i,in_data[i]))  
207 - else:  
208 - log.error(u"#########ERROR#########:\n in_data与数据库查询结果不一致%r"%in_data[i])  
209 - assert False  
210 - return True  
211 -  
212 - elif str(in_data).decode("utf-8").encode("unicode-escape") in result:  
213 - assert True  
214 - log.info(u"in_data与数据库查询结果一致!!%r"%in_data)  
215 - return True  
216 - else:  
217 - log.info(u"#########ERROR#########:\n in_data与数据库查询结果不一致!!%r"%in_data)  
218 - assert False  
219 -  
220 -def Check_in_Response(check_data,src_data):  
221 - #check_data必须为列表形式，src_data必须为r.json()的数据类型  
222 - log.info(u"======从响应Body中查询传入数据======")  
223 - src_data=json.dumps(src_data)  
224 - src_data=src_data.replace(" ","")  
225 - log.info(u"传入check_data为: %s"%check_data)  
226 - log.info(u"对比的响应数据为 %s"%src_data)  
227 - if len(check_data) == 0 or len(src_data)==0:  
228 - log.error(u"传入数据为空!!\n")  
229 - assert False  
230 - return  
231 - elif isinstance (check_data,str) :  
232 - check_data=check_data.replace(" ","").replace("[","").replace("]","").decode("utf-8").split(",")  
233 - for i in range(0,len(check_data)):  
234 - #由于数据库查询的数据中，中文的格式为unicode-escape，所以传入的数据需要进行encode  
235 - check_data[i]=check_data[i].decode("utf-8").encode("unicode-escape")  
236 -# print type(check_data),check_data[i]  
237 - if check_data[i] in src_data:  
238 - assert True  
239 - log.info(u"遍历list第%d次,字段%s在请求响应结果中"%((i+1),check_data[i].decode("unicode-escape")))  
240 - else:  
241 - log.error(u"#########ERROR#########:\n check_data不在请求响应结果中%s"%check_data[i].decode("unicode-escape"))  
242 - assert False  
243 - return True  
244 - elif isinstance (check_data,list) and len(check_data) > 0:  
245 - for i in range(0,len(check_data)):  
246 - #由于数据库查询的数据中，中文的格式为unicode-escape，所以传入的数据需要进行encode  
247 - check_data[i]=check_data[i].decode("utf-8").encode("unicode-escape")  
248 - print(type(check_data),check_data[i],str(check_data[i]))  
249 - print(type(src_data),src_data)  
250 - if check_data[i] in src_data:  
251 - assert True  
252 - log.info(u"遍历list第%d次,插入数据%r与数据库查询结果一致"%(i,check_data[i]))  
253 - else:  
254 - log.error(u"#########ERROR#########:\n check_data数据库查询结果不一致%r"%check_data[i])  
255 - assert False  
256 - return True  
257 - else:  
258 - log.info(u"#########ERROR#########:\n 检查数据有问题，请检查！！！!!%r")  
259 - assert False  
260 -  
261 -  
262 -# test=ca.get_api_config('listCoupon', 'RequstHeader', 'testlist')  
263 -# print type(test),test  
264 -# print test.replace(" ","").replace("[","").replace("]","").decode("utf-8").split(",")  
265 -# test1=test.replace(" ","").replace("[","").replace("]","").decode("utf-8").split(",")  
266 -#  
267 -# a='couponBizType'  
268 -# b='code'  
269 -# data1=[a,b:"200"]  
270 -# data2={"code":"200","data":{"code":u"你好","data":[{"couponBizType":1,"couponCode":"004","couponCode123":"004"}],"result":"OK","success":2},"result":"OK","success":2}  
271 -#  
272 -# print Check_in_Response(data1, data2)  
273 -  
274 -# d=mysql_selectAll("select id as ddd,created_id,name from `product`.tag where id =1")  
275 -# d1=mysql_selectOne("select id,created_id,name from `product`.tag where id =1111")  
276 -# print d  
277 -# print d1  
278 -# print d[0][0]  
279 -# print chardet.detect(str(d))  
280 -# print chardet.detect(str(d[0][2]))  
281 -# mysql_insert(ca.get_api_config('submitOrder', 'coupon', 'insert'))  
282 -# d=ca.get_api_config('submitOrder', 'coupon', 'insert')  
283 -# d=d.decode("utf-8")  
284 -# print d  
285 -# mysql_insert(d)  
286 -  
287 -# c={"couponBizType":1,"couponCode":"004"}  
288 -# a={"code":"200","data":{"code":"200","data":[],"result":"OK","success":1},"result":"OK","success":2}  
289 -# b={"code":"200","data":{"code":"200","data":[{"couponBizType":1,"couponCode":"004","couponCode123":"004"}],"result":"OK","success":2},"result":"OK","success":2}  
290 -# # print json_cmp(a, b)  
291 -# print json_cmp(a, b)  
292 -# print 123  
293 -# mysql_check_insert('listCoupon', 'listCoupon01',1,2,3)  
294 -# a=mysql_selectAll("select * from `order`.orders where id =271")  
295 -# print a  
296 -# if a:  
297 -# print 111  
298 -  
299 -# def string(str1):  
300 -# a=[]  
301 -# b=[]  
302 -# str1= list(str1)  
303 -# print type(str1[0]),type(str1[1]),len(str1)  
304 -# for i in range(len(str1)):  
305 -# if str1[i] in '0123456789':  
306 -# b.append(str1[i])  
307 -# else:  
308 -# a.append(str1[i])  
309 -# a= "".join(a)  
310 -# b= "".join(b)  
311 -# c=a+b  
312 -# return c  
313 -#  
314 -# print string("A1B2c3")  
315 -#  
316 -# assert None, "add assert message"  
317 \ No newline at end of file 22 \ No newline at end of file
  23 + try:
  24 + # 使用execute方法执行SQL语句
  25 + cursor.execute(action)
  26 + data = cursor.fetchone()
  27 + return data
  28 + except Exception as e:
  29 + print("数据库操作异常：%s" % str(e))
  30 + log.error("数据库操作异常：%s" % str(e))
  31 + assert False
  32 + finally:
  33 + # 关闭数据库连接
  34 + db.close()
  35 +
  36 +def mysql_selectAll(select_action):
  37 + action=select_action
  38 + db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8')
  39 + cursor = db.cursor()
  40 + try:
  41 + # 使用execute方法执行SQL语句
  42 + cursor.execute(action)
  43 + # 使用 fetchall() 方法获取所有数据
  44 + data = cursor.fetchall()
  45 +# print data
  46 + return data
  47 + except Exception as e:
  48 + print("数据库操作异常：%s" % str(e))
  49 + log.error("数据库操作异常：%s" % str(e))
  50 + assert False
  51 + finally:
  52 + # 关闭数据库连接
  53 + db.close()
  54 +
  55 +def mysql_delete(delete_action):
  56 + action=delete_action
  57 + db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )
  58 + cursor = db.cursor()
  59 + try:
  60 + # 使用execute方法执行SQL语句
  61 + cursor.execute(action)
  62 + # 提交
  63 + db.commit()
  64 + except Exception as e:
  65 + print("数据库操作异常：%s" % str(e))
  66 + log.error("数据库操作异常：%s" % str(e))
  67 + # 错误回滚
  68 + db.rollback()
  69 + finally:
  70 + # 关闭数据库连接
  71 + db.close()
  72 +
  73 +def mysql_update(update_action):
  74 + action=update_action
  75 + db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )
  76 + cursor = db.cursor()
  77 + try:
  78 + # 使用execute方法执行SQL语句
  79 + cursor.execute(action)
  80 + # 提交
  81 + db.commit()
  82 + except Exception as e:
  83 + print("数据库操作异常：%s" % str(e))
  84 + log.error("数据库操作异常：%s" % str(e))
  85 + # 错误回滚
  86 + db.rollback()
  87 + finally:
  88 + # 关闭数据库连接
  89 + db.close()
  90 +
  91 +def mysql_insert(insert_action):
  92 + action=insert_action
  93 + db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )
  94 + cursor = db.cursor()
  95 + try:
  96 + # 使用execute方法执行SQL语句
  97 + cursor.execute(action)
  98 + # 提交
  99 + db.commit()
  100 + except Exception as e:
  101 + print("数据库操作异常：%s" % str(e))
  102 + log.error("数据库操作异常：%s" % str(e))
  103 + # 错误回滚
  104 + db.rollback()
  105 + finally:
  106 + # 关闭数据库连接
  107 + db.close()
  108 +
  109 +def mysql_check_insert(api,section,check_sql,delete_sql,insert_sql):
  110 + log.info(u"======测试数据准备======")
  111 + check=ca.get_api_config(api, section, check_sql)
  112 + delete=ca.get_api_config(api, section, delete_sql)
  113 + insert=ca.get_api_config(api, section, insert_sql)
  114 +
  115 + try:
  116 + db = MySQLdb.connect(dbhost, dbuser, dbpassword, dbname, charset='utf8' )
  117 + cursor = db.cursor()
  118 + # 使用execute方法执行SQL语句
  119 + cursor.execute(check)
  120 + result=cursor.fetchall()
  121 + # 提交
  122 + db.commit()
  123 + if result:
  124 + log.info(u"检查到数据库有重复数据%r"%str(result))
  125 + log.info(u"删除查询到的重复数据%r"%str(delete))
  126 + cursor.execute(delete)
  127 + log.info(u"删除数据完成")
  128 + log.info(u"向数据库中插入测试数据%r"%str(insert))
  129 + cursor.execute(insert)
  130 + log.info(u"插入数据完成")
  131 + result=cursor.fetchall()
  132 + db.commit()
  133 + return result
  134 + else:
  135 + log.info(u"数据库没有重复数据直接插入自定义数据%r"%str(insert))
  136 + result=cursor.execute(insert)
  137 + log.info(u"插入数据完成，返回结果为为%r"%str(result))
  138 +# cursor.fetchall()
  139 + db.commit()
  140 + return result
  141 +
  142 + except Exception as e:
  143 + print(u"数据库操作异常：%r" % str(e))
  144 + log.error(u"数据库操作异常：%r" % str(e))
  145 + # 错误回滚
  146 + db.rollback()
  147 + assert False
  148 + finally:
  149 + # 关闭数据库连接
  150 + db.close()
  151 +
  152 +def mysql_select_order(orderNum):
  153 + return mysql_selectOne("SELECT * FROM `order`.orders WHERE code = '%s';"%orderNum)
  154 +
  155 +def mysql_delete_order(orderNum):
  156 + mysql_delete("DELETE FROM `order`.orders WHERE code = '%s';"%orderNum)
  157 +
  158 +def mysql_select_coupon(couponNum):
  159 + return mysql_selectOne("SELECT * FROM `customer`.customer_coupon WHERE id = '%s';"%couponNum)
  160 +
  161 +def mysql_delete_coupon(couponNum):
  162 + mysql_delete("DELETE FROM `customer`.customer_coupon WHERE id = '%s';"%couponNum)
  163 +
  164 +
  165 +def Check_in_Mysql(in_data,sql_spm):
  166 + log.info(u"======从数据库中查询传入数据======")
  167 + result=mysql_selectAll(sql_spm)
  168 + log.info(u"传入in_data为: %s"%in_data)
  169 + log.info(u"数据库查询到的结果为 %s"%result)
  170 +
  171 + result=str(result)
  172 + if len(str(in_data)) == 0 and len(result)!=0:
  173 + log.error(u"传入数据为空!!\n")
  174 + assert False
  175 + return
  176 + elif len(str(in_data)) == 0 and len(result)==0:
  177 + log.error(u"传入数据与数据库查询结果都为空!!\n")
  178 + assert False
  179 + return
  180 + elif len(str(in_data)) != 0 and len(result)==0:
  181 + log.error(u"数据库查询结果为空\n")
  182 + assert False
  183 + return
  184 + elif isinstance(in_data,(list)):
  185 + log.info(u'检查的数据格式 为list类型')
  186 + for i in range(0,len(in_data)):
  187 + in_data[i]=str(in_data[i]).decode("utf-8").encode("unicode-escape")
  188 +
  189 + if in_data[i] in result:
  190 + assert True
  191 + log.info(u"遍历list第%d次,插入数据%r与数据库查询结果一致"%(i,in_data[i]))
  192 + else:
  193 + log.error(u"#########ERROR#########:\n in_data与数据库查询结果不一致%r"%in_data[i])
  194 + assert False
  195 + return True
  196 +
  197 + elif str(in_data).decode("utf-8").encode("unicode-escape") in result:
  198 + assert True
  199 + log.info(u"in_data与数据库查询结果一致!!%r"%in_data)
  200 + return True
  201 + else:
  202 + log.info(u"#########ERROR#########:\n in_data与数据库查询结果不一致!!%r"%in_data)
  203 + assert False
  204 +
  205 +def Check_in_Response(check_data,src_data):
  206 + #check_data必须为列表形式，src_data必须为r.json()的数据类型
  207 + log.info(u"======从响应Body中查询传入数据======")
  208 + src_data=json.dumps(src_data)
  209 + src_data=src_data.replace(" ","")
  210 + log.info(u"传入check_data为: %s"%check_data)
  211 + log.info(u"对比的响应数据为 %s"%src_data)
  212 + if len(check_data) == 0 or len(src_data)==0:
  213 + log.error(u"传入数据为空!!\n")
  214 + assert False
  215 + return
  216 + elif isinstance (check_data,str) :
  217 + check_data=check_data.replace(" ","").replace("[","").replace("]","").decode("utf-8").split(",")
  218 + for i in range(0,len(check_data)):
  219 + #由于数据库查询的数据中，中文的格式为unicode-escape，所以传入的数据需要进行encode
  220 + check_data[i]=check_data[i].decode("utf-8").encode("unicode-escape")
  221 +# print type(check_data),check_data[i]
  222 + if check_data[i] in src_data:
  223 + assert True
  224 + log.info(u"遍历list第%d次,字段%s在请求响应结果中"%((i+1),check_data[i].decode("unicode-escape")))
  225 + else:
  226 + log.error(u"#########ERROR#########:\n check_data不在请求响应结果中%s"%check_data[i].decode("unicode-escape"))
  227 + assert False
  228 + return True
  229 + elif isinstance (check_data,list) and len(check_data) > 0:
  230 + for i in range(0,len(check_data)):
  231 + check_data[i]=check_data[i].decode("utf-8").encode("unicode-escape")
  232 + print(type(check_data),check_data[i],str(check_data[i]))
  233 + print(type(src_data),src_data)
  234 + if check_data[i] in src_data:
  235 + assert True
  236 + log.info(u"遍历list第%d次,插入数据%r与数据库查询结果一致"%(i,check_data[i]))
  237 + else:
  238 + log.error(u"#########ERROR#########:\n check_data数据库查询结果不一致%r"%check_data[i])
  239 + assert False
  240 + return True
  241 + else:
  242 + log.info(u"#########ERROR#########:\n 检查数据有问题，请检查！！！!!%r")
  243 + assert False
src/commons/Logging.py
  View file @57fd14e
1 -#!/usr/bin/python  
2 -# -*- coding: UTF-8 -*-  
3 -import logging,os  
4 -  
5 -class Logger():  
6 -  
7 - def __init__(self, path=__name__,clevel = logging.ERROR,Flevel = logging.DEBUG,test = 'w'):  
8 - #test = 'w'时每次日志文件都重新写入，test = 'a'时为追加模式，在原来日志文件上追加日志  
9 - #重写模式的时，发送test.log没有信息，用追加模式可以(注意如果为a时日志可能出现重复,为w时没有这个现象)  
10 - #设置日志路径  
11 - current_path=os.path.dirname(os.path.dirname(__file__))  
12 - path=current_path+"/report"+"/test.log"  
13 -  
14 - self.logger = logging.getLogger(path)  
15 -  
16 - self.logger.setLevel(logging.DEBUG)  
17 -  
18 - fmt = logging.Formatter('[%(asctime)s] [%(levelname)s] : %(message)s', '%Y-%m-%d %H:%M:%S')  
19 -# fmt = logging.Formatter('[%(asctime)s] %(levelname)s [%(name)s,%(funcName)s: %(filename)s, %(lineno)d] %(message)s', '%Y-%m-%d %H:%M:%S')  
20 - #设置CMD日志  
21 -  
22 - sh = logging.StreamHandler()  
23 -  
24 - sh.setFormatter(fmt)  
25 -  
26 - sh.setLevel(clevel)  
27 -  
28 - #设置文件日志  
29 -  
30 - fh = logging.FileHandler(path,mode=test,encoding="utf-8")  
31 -  
32 - fh.setFormatter(fmt)  
33 -  
34 - fh.setLevel(Flevel)  
35 -  
36 - self.logger.addHandler(sh)  
37 -  
38 - self.logger.addHandler(fh)  
39 -  
40 -  
41 - def debug(self,message):  
42 - #初始化得时候self.logger = logging.getLogger(path)  
43 - self.logger.debug(message)  
44 -  
45 - def info(self,message):  
46 -  
47 - self.logger.info(message)  
48 -  
49 -  
50 - def warn(self,message):  
51 -  
52 - self.logger.warn(message)  
53 -  
54 -  
55 - def error(self,message):  
56 -  
57 - self.logger.error(message)  
58 -  
59 -  
60 - def critical(self,message):  
61 -  
62 - self.logger.critical(message)  
63 -  
64 -  
65 -  
66 -  
67 -# a=Logger()  
68 -# a.info("123")  
69 -# from Case_Method.Logging import *  
70 -  
71 -# logcommonsonfig(level=logging.DEBUG, # log level  
72 -# format='[%(asctime)s] %(levelname)s [%(funcName)s: %(filename)s, %(lineno)d] %(message)s', # log格式  
73 -# datefmt='%Y-%m-%d %H:%M:%S', # 日期格式  
74 -# filename='test.log', # 日志输出文件  
75 -# filemode='a') # 追加模式  
76 \ No newline at end of file 1 \ No newline at end of file
  2 +#!/usr/bin/python
  3 +# -*- coding: UTF-8 -*-
  4 +import logging,os
  5 +
  6 +class Logger():
  7 +
  8 + def __init__(self, path=__name__,clevel = logging.ERROR,Flevel = logging.DEBUG,test = 'w'):
  9 + current_path=os.path.dirname(os.path.dirname(__file__))
  10 + path=current_path+"/report"+"/test.log"
  11 +
  12 + self.logger = logging.getLogger(path)
  13 +
  14 + self.logger.setLevel(logging.DEBUG)
  15 +
  16 + fmt = logging.Formatter('[%(asctime)s] [%(levelname)s] : %(message)s', '%Y-%m-%d %H:%M:%S')
  17 +
  18 + sh = logging.StreamHandler()
  19 +
  20 + sh.setFormatter(fmt)
  21 +
  22 + sh.setLevel(clevel)
  23 +
  24 + #设置文件日志
  25 +
  26 + fh = logging.FileHandler(path,mode=test,encoding="utf-8")
  27 +
  28 + fh.setFormatter(fmt)
  29 +
  30 + fh.setLevel(Flevel)
  31 +
  32 + self.logger.addHandler(sh)
  33 +
  34 + self.logger.addHandler(fh)
  35 +
  36 +
  37 + def debug(self,message):
  38 +
  39 + self.logger.debug(message)
  40 +
  41 + def info(self,message):
  42 +
  43 + self.logger.info(message)
  44 +
  45 +
  46 + def warn(self,message):
  47 +
  48 + self.logger.warn(message)
  49 +
  50 +
  51 + def error(self,message):
  52 +
  53 + self.logger.error(message)
  54 +
  55 +
  56 + def critical(self,message):
  57 +
  58 + self.logger.critical(message)
src/commons/SendEmail.py
  View file @57fd14e
1 -#!/usr/bin/python  
2 -# -*- coding: UTF-8 -*-  
3 -import os  
4 -import smtplib # 用于建立smtp连接  
5 -from email.mime.multipart import MIMEMultipart # 混合MIME格式，支持上传附件  
6 -from email.header import Header # 用于使用中文邮件主题  
7 -from email.mime.text import MIMEText # 邮件需要专门的MIME格式  
8 -from email.mime.image import MIMEImage  
9 -from email.mime.application import MIMEApplication  
10 -from commons.Logging import Logger  
11 -log=Logger()  
12 -  
13 -def send_email_text():  
14 - # 1. 编写邮件内容（Email邮件需要专门的MIME格式）  
15 - msg = MIMEText('this is a test email', 'plain', 'utf-8') # plain指普通文本格式邮件内容  
16 -  
17 - # 2. 组装Email头（发件人，收件人，主题）  
18 - msg['From'] = '328351418@qq.com' # 发件人  
19 - msg['To'] = '328351418@qq.com' # 收件人  
20 - msg['Subject'] = 'Api Test Report' # 邮件主题  
21 -  
22 - # 3. 连接smtp服务器并发送邮件  
23 - smtp = smtplib.SMTP_SSL('smtp.qq.com') # smtp服务器地址 使用SSL模式  
24 - smtp.login('328351418@qq.com', 'apebatdwkggkbiee') # 用户名和密码  
25 - smtp.sendmail("328351418@qq.com", "328351418@qq.com", msg.as_string())  
26 - smtp.quit()  
27 -  
28 -  
29 -def send_email(send_file,send_to=["lixi@diligrp.com","328351418@qq.com"]):  
30 -  
31 - log_path=os.path.dirname(os.path.dirname(__file__))  
32 - log_path=log_path+"/report/test.log"  
33 - msg = MIMEMultipart() # 混合MIME格式  
34 - msg['From'] = '328351418@qq.com' # 发件人  
35 - msg['To'] = '175930106@qq.com' # 收件人  
36 - msg['Subject'] = Header('接口测试报告', 'utf-8') # 中文邮件主题，指定utf-8编码  
37 -  
38 - text = MIMEText('this is a test email', 'plain', 'utf-8')  
39 - msg.attach(MIMEText(open(send_file,'rb' ).read(), 'html', 'utf-8')) # 邮件正文添加html格式内容（会丢失css格式）  
40 -  
41 - att1 = MIMEText(open(send_file, 'rb').read(), 'base64', 'utf-8') # 二进制格式打开需要添加的附件  
42 - att1["Content-Type"] = 'application/octet-stream'  
43 - att1["Content-Disposition"] = 'attachment; filename="report.html"' # filename为邮件中附件显示的名字  
44 -  
45 -# att2 = MIMEText(open("../Case_Report/test.log", 'rb').read(), 'base64', 'utf-8') # 二进制格式打开需要添加的附件  
46 - att2 = MIMEText(open(log_path, 'rb').read(), 'base64', 'utf-8') # 二进制格式打开需要添加的附件  
47 - att2["Content-Type"] = 'application/octet-stream'  
48 - att2["Content-Disposition"] = 'attachment; filename="test.log"' # filename为邮件中附件显示的名字  
49 - msg.attach(text)  
50 - msg.attach(att1)  
51 - msg.attach(att2)  
52 -  
53 - #一下发送日志不会在test.log上，因为提前msg.attach了  
54 - log.info("发送邮件")  
55 - try:  
56 - smtp = smtplib.SMTP_SSL('smtp.qq.com') # smtp服务器地址 使用SSL模式  
57 - re=smtp.login('328351418@qq.com', 'wveicahctcizbghh') # 用户名和密码  
58 - smtp.sendmail("328351418@qq.com", send_to, msg.as_string())  
59 - print(re)  
60 -# smtp.sendmail("328351418@qq.com", "328351418@qq.com", msg.as_string()) # 发送给另一个邮箱  
61 -# logging.info("邮件发送完成！")  
62 - except Exception as e:  
63 - log.error(str(e))  
64 - print(e)  
65 - finally:  
66 - smtp.quit()  
67 - log.info("邮件发送完毕")  
68 -  
69 -  
70 -#  
71 -# f='E:\\EclipseWorkspace\\\WorksapceDemo\\Request-demo\\src\\report\\2019-11-28 15_39_01_result.html'  
72 -# send_email(send_file=f)  
73 -# fromaddr = '328351418@qq.com'  
74 -# password = 'apebatdwkggkbiee'  
75 -# toaddrs = ['328351418@qq.com', '328351418@qq.com']  
76 -#  
77 -# content = 'hello, this is email content.'  
78 -# textApart = MIMEText(content)  
79 -#  
80 -# imageFile = 'E:\\EclipseWorkspace\\nong12test\\Request-fresh\\src\\Case_Report\\report.html'  
81 -# imageApart = MIMEApplication(open(imageFile, 'rb').read())  
82 -# imageApart.add_header('Content-Disposition', 'attachment', filename='report.html')  
83 -#  
84 -# # pdfFile = '算法设计与分析基础第3版PDF.pdf'  
85 -# # pdfApart = MIMEApplication(open(pdfFile, 'rb').read())  
86 -# # pdfApart.add_header('Content-Disposition', 'attachment', filename=pdfFile)  
87 -# #  
88 -# #  
89 -# # zipFile = '算法设计与分析基础第3版PDF.zip'  
90 -# # zipApart = MIMEApplication(open(zipFile, 'rb').read())  
91 -# # zipApart.add_header('Content-Disposition', 'attachment', filename=zipFile)  
92 -#  
93 -# m = MIMEMultipart()  
94 -# m.attach(textApart)  
95 -# m.attach(imageApart)  
96 -# # m.attach(pdfApart)  
97 -# # m.attach(zipApart)  
98 -# m['Subject'] = 'TEST REPORT'  
99 -# m['From'] = '328351418@qq.com'  
100 -# m['to'] = '175930106@qq.com'  
101 -#  
102 -# try:  
103 -# server = smtplib.SMTP('smtp.qq.com')  
104 -# server.login(fromaddr,password)  
105 -# server.sendmail(fromaddr, toaddrs, m.as_string())  
106 -# print('success')  
107 -# server.quit()  
108 -# except smtplib.SMTPException as e:  
109 -# print('error:',e) #打印错误  
110 -#  
111 -#  
112 -# # file='E:\\EclipseWorkspace\\nong12test\\Request-fresh\\src\\Case_Report\\2019-01-28 17_54_18_result.html'  
113 -# #  
114 -# # email(file)  
115 \ No newline at end of file 1 \ No newline at end of file
  2 +#!/usr/bin/python
  3 +# -*- coding: UTF-8 -*-
  4 +import os
  5 +import smtplib
  6 +from email.mime.multipart import MIMEMultipart
  7 +from email.header import Header
  8 +from email.mime.text import MIMEText
  9 +from email.mime.image import MIMEImage
  10 +from email.mime.application import MIMEApplication
  11 +from commons.Logging import Logger
  12 +log=Logger()
  13 +
  14 +def send_email_text():
  15 + # 1. 编写邮件内容（Email邮件需要专门的MIME格式）
  16 + msg = MIMEText('this is a test email', 'plain', 'utf-8')
  17 +
  18 + # 2. 组装Email头（发件人，收件人，主题）
  19 + msg['From'] = '328351418@qq.com' # 发件人
  20 + msg['To'] = '328351418@qq.com' # 收件人
  21 + msg['Subject'] = 'Api Test Report' # 邮件主题
  22 +
  23 + # 3. 连接smtp服务器并发送邮件
  24 + smtp = smtplib.SMTP_SSL('smtp.qq.com')
  25 + smtp.login('328351418@qq.com', 'apebatdwkggkbiee')
  26 + smtp.sendmail("328351418@qq.com", "328351418@qq.com", msg.as_string())
  27 + smtp.quit()
  28 +
  29 +
  30 +def send_email(send_file,send_to=["lixi@diligrp.com","328351418@qq.com"]):
  31 +
  32 + log_path=os.path.dirname(os.path.dirname(__file__))
  33 + log_path=log_path+"/report/test.log"
  34 + msg = MIMEMultipart() # 混合MIME格式
  35 + msg['From'] = '328351418@qq.com' # 发件人
  36 + msg['To'] = '175930106@qq.com' # 收件人
  37 + msg['Subject'] = Header('接口测试报告', 'utf-8') # 中文邮件主题，指定utf-8编码
  38 +
  39 + text = MIMEText('this is a test email', 'plain', 'utf-8')
  40 + msg.attach(MIMEText(open(send_file,'rb' ).read(), 'html', 'utf-8'))
  41 +
  42 + att1 = MIMEText(open(send_file, 'rb').read(), 'base64', 'utf-8')
  43 + att1["Content-Disposition"] = 'attachment; filename="report.html"'
  44 +
  45 + att2 = MIMEText(open(log_path, 'rb').read(), 'base64', 'utf-8')
  46 + att2["Content-Type"] = 'application/octet-stream'
  47 + att2["Content-Disposition"] = 'attachment; filename="test.log"'
  48 + msg.attach(text)
  49 + msg.attach(att1)
  50 + msg.attach(att2)
  51 +
  52 + #一下发送日志不会在test.log上，因为提前msg.attach了
  53 + log.info("发送邮件")
  54 + try:
  55 + smtp = smtplib.SMTP_SSL('smtp.qq.com') # smtp服务器地址 使用SSL模式
  56 + re=smtp.login('328351418@qq.com', 'wveicahctcizbghh') # 用户名和密码
  57 + smtp.sendmail("328351418@qq.com", send_to, msg.as_string())
  58 + print(re)
  59 + except Exception as e:
  60 + log.error(str(e))
  61 + print(e)
  62 + finally:
  63 + smtp.quit()
  64 + log.info("邮件发送完毕")
src/commons/common.py
  View file @57fd14e
1 -#!/usr/bin/python  
2 -# -*- coding: UTF-8 -*-  
3 -import os  
4 -import operator  
5 -import configparser  
6 -import requests  
7 -import json  
8 -from commons.Logging import Logger  
9 -import urllib3  
10 -urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)  
11 -log=Logger()  
12 -  
13 -  
14 -def get_global_config(file,section, key):  
15 -  
16 - current_path=os.path.dirname(__file__)  
17 - src_path=os.path.dirname(current_path)  
18 -# global_setting_path=src_path+'/config/global_data.conf'  
19 - global_setting_path=src_path+'/config/'+file+".conf"  
20 - #验证文件是否存在  
21 - file_path = os.path.exists(global_setting_path)  
22 - if file_path:  
23 - #获取文件的数据  
24 - if isinstance(key,int):  
25 - log.error("key of section cannot be int Type :<%r> "%str(key))  
26 - raise Exception("key of section cannot be int Type :<%r> "%str(key))  
27 - else:  
28 - config = configparser.ConfigParser()  
29 - config.read(global_setting_path,encoding="utf-8")  
30 - return config.get(section, key)  
31 - else:  
32 - log.error("File Not Exist :<%r> "%str(global_setting_path))  
33 - raise Exception("File Not Exist :<%r> "%str(global_setting_path))  
34 -  
35 -  
36 -def get_api_config(api,section,key):  
37 - current_path=os.path.dirname(__file__)  
38 - src_path=os.path.dirname(current_path)  
39 - api_path=src_path+"/config/api/"  
40 - api_config_path=api_path+api+".conf"  
41 - #验证文件是否存在  
42 - file_path = os.path.exists(api_config_path)  
43 - if file_path:  
44 - #获取文件的数据  
45 - if isinstance(key,int):  
46 - log.error("key of section cannot be int Type :<%r> "%str(key))  
47 - raise Exception("key of section cannot be int Type :<%r> "%str(key))  
48 - else:  
49 - config = configparser.ConfigParser()  
50 - config.read(api_config_path,encoding="utf-8")  
51 - return config.get(section, key)  
52 - else:  
53 - log.error("File Not Exist :<%r> "%str(api_config_path))  
54 - raise Exception("File Not Exist :<%r> "%str(api_config_path))  
55 -  
56 -def set_global_config(file,section, key,value):  
57 - current_path=os.path.dirname(__file__)  
58 - src_path=os.path.dirname(current_path)  
59 -# global_setting_path=src_path+'/config/global_data.conf'  
60 - global_setting_path=src_path+'/config/'+file+".conf"  
61 - #验证文件是否存在  
62 - file_path = os.path.exists(global_setting_path)  
63 - if file_path:  
64 - #获取文件的数据  
65 - if isinstance(key,int):  
66 - log.error("key of section cannot be int Type :<%r> "%str(key))  
67 - raise Exception("key of section cannot be int Type :<%r> "%str(key))  
68 - else:  
69 - config = configparser.ConfigParser()  
70 - config.read(global_setting_path,encoding="utf-8")  
71 - config.set(section, key, value)  
72 - config.write(open(global_setting_path, "w"))  
73 -  
74 - return config.get(section, key)  
75 - else:  
76 - log.error("File Not Exist :<%r> "%str(global_setting_path))  
77 - raise Exception("File Not Exist :<%r> "%str(global_setting_path))  
78 -  
79 -def set_priority(priority_list):  
80 - #用户自定义优先级方法，设定有需要运行的用例优先级  
81 - #方法内定义global全局变量可以真正通过这个方法设置一个全局的值，如果global放在外面，方法内的变量都是临时的，  
82 - #接上面：即使名称和外面的全局变量相同，方法内的变量和外面的全局变量完全是两码事，外面的全局变量不会受干扰  
83 - global _global_priority  
84 - if priority_list:  
85 - _global_priority=priority_list  
86 - return _global_priority  
87 - else:  
88 - _global_priority=[1,2,3]  
89 - return _global_priority  
90 -  
91 -def set_mark(case_mark):  
92 - #用户自定义优先级方法，设定有需要运行的用例优先级  
93 - global _global_mark  
94 - if case_mark:  
95 - _global_mark=case_mark  
96 - return _global_mark  
97 - else:  
98 - _global_mark=False  
99 - return _global_mark  
100 -  
101 -def read_priority_list():  
102 - #需要重新设定一个方法来读取配置的全局优先级变量,且必须在全局变量初始化后使用，不然会报错  
103 - #如果直接再py文件中加入类似p=set_priority_list()的代码，之前用户自定义的优先级配置将会失效  
104 - priority_list=[1,2,3]  
105 - try:  
106 - return _global_priority  
107 - except Exception as e:  
108 - return priority_list  
109 -  
110 -def read_case_mark():  
111 - #需要重新设定一个方法来读取配置的全局优先级变量,且必须在全局变量初始化后使用，不然会报错  
112 - #如果直接再py文件中加入类似p=set_priority_list()的代码，之前用户自定义的优先级配置将会失效  
113 - casemark=False  
114 - try:  
115 - return _global_mark  
116 - except Exception as e:  
117 - return casemark  
118 -  
119 -def mark(tag=None,p=None):  
120 - #此处的try主要用于，当用户需要直接运行单个用例文件时，没提前_global_priority和_global_mark初始化  
121 - #如果不加try处理，那么_global_priority和_global_mark没有初始化时，单独运行一个引用了mark方法的用例文件会报错  
122 - try:  
123 - #用户没有输入任何值  
124 - if _global_priority == [1,2,3] and _global_mark == False :  
125 - return True  
126 - #只指定用例标签  
127 - elif _global_priority == [1,2,3] and _global_mark != False:  
128 - if tag == _global_mark:  
129 - return True  
130 - else:  
131 - return False  
132 - #只指定用例优先级  
133 - elif _global_priority != [1,2,3] and _global_mark == False:  
134 - if p in _global_priority:  
135 - return True  
136 - else:  
137 - return False  
138 - #同时指定优先级和标签  
139 - elif _global_priority != [1,2,3] and _global_mark != False:  
140 - if p in _global_priority and tag == _global_mark:  
141 - return True  
142 - else:  
143 - return False  
144 - #若直接在用例文件中运行那么_global_mark和_global_priority都不会被定义，会导致异常  
145 - #这里的try用来当上述两个变量未定义时，默认跑当前文件的用例  
146 - except Exception as e:  
147 - return True  
148 -  
149 -  
150 -def get_session(name,password):  
151 - pass  
152 - return "header"  
153 -  
154 -def get_token(name,password):  
155 - pass  
156 - return "token"  
157 -  
158 -def get_request_Url(api):  
159 - return get_api_config(api,'RequestUrl', 'url')  
160 -  
161 -def get_request_Json(api):  
162 - return get_api_config(api,'JsonStructrue', 'requestJson')  
163 -  
164 -# def post_request(api_url, argu, headers):  
165 -# #传值前最好要进行一个类型判断，以免数据类型没有转换正确，或者重复转换，导致调用接口时失败  
166 -# test_headers=json.loads(headers)  
167 -# r = requests.post(api_url, data=argu, headers=test_headers)  
168 -# return r  
169 -  
170 -def dict_diff(a1,b1):  
171 - #提取出dict与str或list的异常对比场景  
172 - if type(a1)!= type(b1):  
173 - print("实际响应json的元素{}的类型{}和期望响应json元素{}的类型{}不一致".format(a1,type(a1),b1,type(b1)))  
174 - return False  
175 - d1=list(set(a1.keys()).difference(set(b1.keys())))  
176 - d2=list(set(b1.keys()).difference(set(a1.keys())))  
177 - if len(d1)==0 and len(d2)==0:  
178 - return True  
179 - else:  
180 - print("实际json比期望json多了键值",d1)  
181 - print("实际json比期望json少了键值",d2)  
182 - return False  
183 -  
184 -def list_diff(a1,b1):  
185 - #提取出list与str或dict的异常对比场景  
186 - if type(a1)!= type(b1):  
187 - print("实际响应json的元素{}的类型{}和期望响应json元素{}的类型{}不一致".format(a1,type(a1),b1,type(b1)))  
188 - return False  
189 - elif len(a1)!=len(b1):  
190 - print("实际响应json列表长度{}和期望响应json列表长度{}不一致".format(a1,b1))  
191 - return False  
192 - else:  
193 - return True  
194 -  
195 -#无法判断[[1],[2]]和[[1],[1]]的区别,只能判断列表长度和字典键值是否一致  
196 -#a为实际对比的json数据,b为期望的json数据  
197 -def compare_json(a,b):  
198 - #判断检查数据是否为列表格式的数据  
199 - if isinstance(a,list):  
200 - if list_diff(a,b)==True:  
201 - #为列表时必须进行排序,否则可能出现列表对比的位置不一致  
202 - a.sort()  
203 - b.sort()  
204 - for i in range(len(a)):  
205 - #判断列表中的指定的元素是否为字典格式  
206 - if compare_json(a[i],b[i]) == False:  
207 - return False  
208 - else:  
209 - return False  
210 - #判断检查数据是否为字典格式的数据  
211 - elif isinstance(a,dict):  
212 - if dict_diff(a,b)==True:  
213 - #如果第一层键值相同时,遍历检查内层所有键值  
214 - for key in a.keys():  
215 - #内层键值为列表数据类型时  
216 - if compare_json(a[key],b[key]) == False:  
217 - return False  
218 - else:  
219 - return False  
220 - #期望数据非dict和list类型时,直接进行对比,可能会导致{"code":"200"}，{"code":"201"}出现不同的情况，所以注释下面的结果  
221 -# elif operator.eq(a, b)==False:  
222 -# print("实际数据的{}和期望数据的{}不一致".format(a,b))  
223 -# return False  
224 -  
225 -#接口返回值是可控的情况可以用下面这个方法  
226 -def cmp_json(actual_data,expect_data):  
227 - log.info("======对比期望和实际响应Json格式======")  
228 - try:  
229 - if len(expect_data)!=0 and len(actual_data)!=0:  
230 - expect_data=json.loads(expect_data)  
231 - result=compare_json(actual_data,expect_data)  
232 - if result==None:  
233 - log.info("响应数据和期望数据的Json格式一致")  
234 - return True  
235 - else:  
236 - log.error("66响应数据和期望数据的Json格式不一致")  
237 - return False  
238 - elif len(expect_data)!=0 and len(actual_data)==0:  
239 - log.error("对比数据中，实际响应数据为空")  
240 - assert False  
241 - elif len(expect_data)==0 and len(actual_data)!=0:  
242 - log.error("对比数据中，期望响应数据为空，请检查配置文件")  
243 - assert False  
244 - elif len(expect_data)==0 and len(actual_data)==0:  
245 - log.error("对比数据都为空")  
246 - assert False  
247 - except Exception as e:  
248 - log.error("对比响应数据和期望数据的Json格式 ERROR == %s"%e)  
249 - return False  
250 -  
251 -def get_to_post(data):  
252 - #需要传入get格式的请求,如：id=638&driver=好司机&licensePlate=车辆信息,返回字典类型数据  
253 - if isinstance(data, str):  
254 - test={i.split("=",1)[0]:i.split("=")[1] for i in data.split("&")}  
255 - return test  
256 - else:  
257 - raise Exception("transformation data must be str type")  
258 -  
259 -def post_to_get(data):  
260 - if isinstance(data, dict):  
261 - #字典类型,格式如{'id':'668','driver':'好司机'}或者{"id":"668","driver":"好司机"}  
262 - test=json.dumps(data)  
263 - test=test.replace(" ","").replace('":"', '=').replace('","', "&").replace('"', '').replace("{", "").replace("}", "")  
264 - return test.encode('utf_8').decode("unicode_escape")  
265 - elif isinstance(data, str):  
266 - if '"' in data:  
267 - #字符串类型,格式如str({'id':'668','driver':'好司机'})  
268 - test=data.replace(" ","").replace('":"', '=').replace('","', "&").replace('"', '').replace("{", "").replace("}", "")  
269 - return test  
270 - elif "'" in data:  
271 - #json字符串类型,格式如str({"id":"668","driver":"好司机"})  
272 - test=data.replace(" ","").replace("':'", "=").replace("','", "&").replace("'", "").replace("{", "").replace("}", "")  
273 - return test  
274 - else:  
275 - raise Exception("pls check your transformation data")  
276 -  
277 -def get_request(api,caseNum):  
278 - #传值前最好要进行一个类型判断，以免数据类型没有转换正确，或者重复转换，导致调用接口时失败  
279 - if 'http' in api.replace(' ',''):  
280 - log.info(u"======直接调用GET请求%s======"%api)  
281 - r = requests.post(api, headers=caseNum,verify=False)  
282 - else:  
283 - URL=get_api_config(api,'RequstURL', 'url')  
284 - #获取header  
285 - headers=get_api_config(api,'RequstHeader', 'header')  
286 - if 'none' == headers:  
287 - #header=str(获取有session和token的header)  
288 - pass  
289 - headers=json.loads(headers)  
290 - #获取URI  
291 - params=get_api_config(api,caseNum, 'URL_params')  
292 - params=params.replace("[","").replace("]","")  
293 - URI=URL+params  
294 - #进行get请求  
295 - r = requests.get(URI,headers=headers)  
296 - if r.status_code == 200:  
297 - # 关闭请求 释放内存  
298 - r.close()  
299 - return r  
300 - else:  
301 - r.close()  
302 - log.error(u"Request code==%s ! Response Code is not 200,Pls Check Your Request Datas"%(r.status_code))  
303 - raise Exception(u"Request Fail! Response Code is not 200,Pls Check Your Request Datas")  
304 - return r  
305 -  
306 -  
307 -def post_request(api,caseNum,requestBody):  
308 - #设置重连次数  
309 - requests.adapters.DEFAULT_RETRIES = 5  
310 - # 设置连接活跃状态为False  
311 - s = requests.session()  
312 - s.keep_alive = False  
313 - #判断post方法使用方式  
314 - if 'http' in api.replace(' ',''):  
315 - log.info(u"======直接调用POST请求%s======"%api)  
316 - r = requests.post(api, headers=caseNum,data=requestBody,verify=False)  
317 - else:  
318 - log.info(u"======配置相关参数，调用POST请求%s======"%caseNum)  
319 - #传值前最好要进行一个类型判断，以免数据类型没有转换正确，或者重复转换，导致调用接口时失败  
320 - #获取请求地址数据  
321 - url=get_api_config(api,'RequstURL', 'url')  
322 - #获取请求header数据  
323 - header=get_api_config(api,'RequstHeader', 'header')  
324 - if 'none' == header:  
325 - #header=str(获取有session和token的header)  
326 - pass  
327 - #获取请求body数据  
328 - body=get_api_config(api,caseNum,requestBody)  
329 - #获取请求备注内容  
330 - notes=get_api_config(api,caseNum,'notes')  
331 - #获取请求期望json格式  
332 - expect_Response=get_api_config(api,caseNum,'expect_Response')  
333 - #把转换header类型  
334 - test_headers=json.loads(header)  
335 - #避免日志中的中文乱码，进行编码转换  
336 - test_body=json.dumps(json.loads(body)).decode('unicode_escape')  
337 - #调用post请求  
338 - r = requests.post(url, data=body, headers=test_headers,verify=False)  
339 - #进行日志记录  
340 - log.info(u"NUM:%s | 请求备注 ==%s"%(caseNum,notes))  
341 - log.info(u"NUM:%s | 请求URL==%s"%(caseNum,url))  
342 - log.info(u"NUM:%s | 请求body==%s"%(caseNum,test_body))  
343 - log.info(u"NUM:%s | 请求实际响应格式 ==%s"%(caseNum,r.content))  
344 - log.info(u"NUM:%s | 请求期望响应格式 ==%s"%(caseNum,expect_Response))  
345 - #判断请求是否成功  
346 - if r.status_code == 200:  
347 - # 关闭请求 释放内存  
348 - r.close()  
349 - return r  
350 - else:  
351 - r.close()  
352 - log.error(u"Request code==%s ! Response Code is not 200,Pls Check Your Request Datas"%(r.status_code))  
353 - raise Exception(u"Request Fail! Response Code is not 200,Pls Check Your Request Datas")  
354 -  
355 -  
356 -  
357 -  
358 -# def my  
359 -  
360 -# a='https://gateway.fresh.nong12.com/getCityByPosition?lat=30.661286&lng=104.067624'  
361 -# b={  
362 -# "Host": "gateway.fresh.nong12.com",  
363 -# "Content-Type": "application/json",  
364 -# "referer": "https://servicewechat.com/wxd1405e5c40ff05db/0/page-frame.html",  
365 -# "apiusertoken": "dili-fresh-token",  
366 -# "charset": "utf-8",  
367 -# "Accept-Encoding": "gzip",  
368 -# "User-Agent": "Mozilla/5.0 (Linux; Android 7.0; HUAWEI NXT-AL10 Build/HUAWEINXT-AL10; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/59.0.3071.125 Mobile Safari/537.36 MicroMessenger/6.7.3.1360(0x2607033D) NetType/WIFI Language/zh_CN Process/appbrand2"  
369 -# }  
370 -# print get_request('getCityByPosition','getCityByPosition01').json()  
371 -# a= get_api_config('submitOrder', 'RequstHeader', 'header')  
372 -# b= get_global_config('basic_data_prepare', 'instert_customer')  
373 -# print(a)  
374 -# print(b)  
375 -# print type(a)  
376 -# a=json.loads(a)  
377 -# print a  
378 -# a=json.dumps(a)  
379 -# print a  
380 -# print a  
381 -# a=post_request('nearBy', 'nearBy01', 'requestBody')  
382 -# # b=get_api_config('listCoupon', 'listCoupon01', 'expect_Response')  
383 -# print a.json()  
384 -# print json_compare(b, a.json())  
385 -# a=['code', 'data', 'result', 'success']  
386 -# b=['code', 'data', 'result', 'success']  
387 -# print str(b)  
388 -# print json_compare(str(b), a)  
389 -  
390 -# print a.content  
391 -# a=post_request('www.baidu.com/',"" ,"" )  
392 -# print a.headers  
393 -# print type(a)  
394 -# b=json.loads(a)  
395 -# c=json.dumps(json.loads(a)).decode('unicode_escape')  
396 -# print c  
397 -# a={"code":"200","data":{"code":"200","data":[],"result":"OK","success":1},"result":"OK","success":2}  
398 -# b={"code":"200","data":{"code":"200","data":[{"couponBizType":1,"couponCode":"004","couponConditionValue":0,"couponDescription":"auto","couponDiscount":1000,"couponDuration":10,"couponName":"成勇测试01","couponTimeEnd":"2025-01-26 23:59:59","couponTimeSt":"2019-01-17 00:00:00","couponType":2,"created":"2019-01-17 15:14:15","customerCode":"00010966","id":10000,"isUsable":2,"state":1,"version":1}],"result":"OK","success":2},"result":"OK","success":2}  
399 -# print type(a),type(b)  
400 -# prjson_cmp(a, b)  
401 \ No newline at end of file 1 \ No newline at end of file
  2 +#!/usr/bin/python
  3 +# -*- coding: UTF-8 -*-
  4 +import os
  5 +import operator
  6 +import configparser
  7 +import requests
  8 +import json
  9 +from commons.Logging import Logger
  10 +import urllib3
  11 +urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
  12 +log=Logger()
  13 +
  14 +
  15 +def get_global_config(file,section, key):
  16 +
  17 + current_path=os.path.dirname(__file__)
  18 + src_path=os.path.dirname(current_path)
  19 +# global_setting_path=src_path+'/config/global_data.conf'
  20 + global_setting_path=src_path+'/config/'+file+".conf"
  21 + #验证文件是否存在
  22 + file_path = os.path.exists(global_setting_path)
  23 + if file_path:
  24 + #获取文件的数据
  25 + if isinstance(key,int):
  26 + log.error("key of section cannot be int Type :<%r> "%str(key))
  27 + raise Exception("key of section cannot be int Type :<%r> "%str(key))
  28 + else:
  29 + config = configparser.ConfigParser()
  30 + config.read(global_setting_path,encoding="utf-8")
  31 + return config.get(section, key)
  32 + else:
  33 + log.error("File Not Exist :<%r> "%str(global_setting_path))
  34 + raise Exception("File Not Exist :<%r> "%str(global_setting_path))
  35 +
  36 +
  37 +def get_api_config(api,section,key):
  38 + current_path=os.path.dirname(__file__)
  39 + src_path=os.path.dirname(current_path)
  40 + api_path=src_path+"/config/api/"
  41 + api_config_path=api_path+api+".conf"
  42 + #验证文件是否存在
  43 + file_path = os.path.exists(api_config_path)
  44 + if file_path:
  45 + #获取文件的数据
  46 + if isinstance(key,int):
  47 + log.error("key of section cannot be int Type :<%r> "%str(key))
  48 + raise Exception("key of section cannot be int Type :<%r> "%str(key))
  49 + else:
  50 + config = configparser.ConfigParser()
  51 + config.read(api_config_path,encoding="utf-8")
  52 + return config.get(section, key)
  53 + else:
  54 + log.error("File Not Exist :<%r> "%str(api_config_path))
  55 + raise Exception("File Not Exist :<%r> "%str(api_config_path))
  56 +
  57 +
  58 +def set_priority(priority_list):
  59 + #用户自定义优先级方法，设定有需要运行的用例优先级
  60 + global _global_priority
  61 + if priority_list:
  62 + _global_priority=priority_list
  63 + return _global_priority
  64 + else:
  65 + _global_priority=[1,2,3]
  66 + return _global_priority
  67 +
  68 +def set_mark(case_mark):
  69 + #用户自定义优先级方法，设定有需要运行的用例优先级
  70 + global _global_mark
  71 + if case_mark:
  72 + _global_mark=case_mark
  73 + return _global_mark
  74 + else:
  75 + _global_mark=False
  76 + return _global_mark
  77 +
  78 +def read_priority_list():
  79 + #需要重新设定一个方法来读取配置的全局优先级变量,且必须在全局变量初始化后使用，不然会报错
  80 + priority_list=[1,2,3]
  81 + try:
  82 + return _global_priority
  83 + except Exception as e:
  84 + return priority_list
  85 +
  86 +def read_case_mark():
  87 + #需要重新设定一个方法来读取配置的全局优先级变量,且必须在全局变量初始化后使用，不然会报错
  88 + casemark=False
  89 + try:
  90 + return _global_mark
  91 + except Exception as e:
  92 + return casemark
  93 +
  94 +def mark(tag=None,p=None):
  95 + #此处的try主要用于，当用户需要直接运行单个用例文件时，没提前_global_priority和_global_mark初始化
  96 + try:
  97 + #用户没有输入任何值
  98 + if _global_priority == [1,2,3] and _global_mark == False :
  99 + return True
  100 + #只指定用例标签
  101 + elif _global_priority == [1,2,3] and _global_mark != False:
  102 + if tag == _global_mark:
  103 + return True
  104 + else:
  105 + return False
  106 + #只指定用例优先级
  107 + elif _global_priority != [1,2,3] and _global_mark == False:
  108 + if p in _global_priority:
  109 + return True
  110 + else:
  111 + return False
  112 + #同时指定优先级和标签
  113 + elif _global_priority != [1,2,3] and _global_mark != False:
  114 + if p in _global_priority and tag == _global_mark:
  115 + return True
  116 + else:
  117 + return False
  118 + except Exception as e:
  119 + return True
  120 +
  121 +
  122 +def get_session(name,password):
  123 + pass
  124 + return "header"
  125 +
  126 +def get_token(name,password):
  127 + pass
  128 + return "token"
  129 +
  130 +def get_request_Url(api):
  131 + return get_api_config(api,'RequestUrl', 'url')
  132 +
  133 +def get_request_Json(api):
  134 + return get_api_config(api,'JsonStructrue', 'requestJson')
  135 +
  136 +
  137 +def dict_diff(a1,b1):
  138 + #提取出dict与str或list的异常对比场景
  139 + if type(a1)!= type(b1):
  140 + print("实际响应json的元素{}的类型{}和期望响应json元素{}的类型{}不一致".format(a1,type(a1),b1,type(b1)))
  141 + return False
  142 + d1=list(set(a1.keys()).difference(set(b1.keys())))
  143 + d2=list(set(b1.keys()).difference(set(a1.keys())))
  144 + if len(d1)==0 and len(d2)==0:
  145 + return True
  146 + else:
  147 + print("实际json比期望json多了键值",d1)
  148 + print("实际json比期望json少了键值",d2)
  149 + return False
  150 +
  151 +def list_diff(a1,b1):
  152 + #提取出list与str或dict的异常对比场景
  153 + if type(a1)!= type(b1):
  154 + print("实际响应json的元素{}的类型{}和期望响应json元素{}的类型{}不一致".format(a1,type(a1),b1,type(b1)))
  155 + return False
  156 + elif len(a1)!=len(b1):
  157 + print("实际响应json列表长度{}和期望响应json列表长度{}不一致".format(a1,b1))
  158 + return False
  159 + else:
  160 + return True
  161 +
  162 +#无法判断[[1],[2]]和[[1],[1]]的区别,只能判断列表长度和字典键值是否一致
  163 +#a为实际对比的json数据,b为期望的json数据
  164 +def compare_json(a,b):
  165 + #判断检查数据是否为列表格式的数据
  166 + if isinstance(a,list):
  167 + if list_diff(a,b)==True:
  168 + #为列表时必须进行排序,否则可能出现列表对比的位置不一致
  169 + a.sort()
  170 + b.sort()
  171 + for i in range(len(a)):
  172 + #判断列表中的指定的元素是否为字典格式
  173 + if compare_json(a[i],b[i]) == False:
  174 + return False
  175 + else:
  176 + return False
  177 + #判断检查数据是否为字典格式的数据
  178 + elif isinstance(a,dict):
  179 + if dict_diff(a,b)==True:
  180 + #如果第一层键值相同时,遍历检查内层所有键值
  181 + for key in a.keys():
  182 + #内层键值为列表数据类型时
  183 + if compare_json(a[key],b[key]) == False:
  184 + return False
  185 + else:
  186 + return False
  187 + #期望数据非dict和list类型时,直接进行对比,可能会导致{"code":"200"}，{"code":"201"}出现不同的情况，所以注释下面的结果
  188 +# elif operator.eq(a, b)==False:
  189 +# print("实际数据的{}和期望数据的{}不一致".format(a,b))
  190 +# return False
  191 +
  192 +#接口返回值是可控的情况可以用下面这个方法
  193 +def cmp_json(actual_data,expect_data):
  194 + log.info("======对比期望和实际响应Json格式======")
  195 + try:
  196 + if len(expect_data)!=0 and len(actual_data)!=0:
  197 + expect_data=json.loads(expect_data)
  198 + result=compare_json(actual_data,expect_data)
  199 + if result==None:
  200 + log.info("响应数据和期望数据的Json格式一致")
  201 + return True
  202 + else:
  203 + log.error("66响应数据和期望数据的Json格式不一致")
  204 + return False
  205 + elif len(expect_data)!=0 and len(actual_data)==0:
  206 + log.error("对比数据中，实际响应数据为空")
  207 + assert False
  208 + elif len(expect_data)==0 and len(actual_data)!=0:
  209 + log.error("对比数据中，期望响应数据为空，请检查配置文件")
  210 + assert False
  211 + elif len(expect_data)==0 and len(actual_data)==0:
  212 + log.error("对比数据都为空")
  213 + assert False
  214 + except Exception as e:
  215 + log.error("对比响应数据和期望数据的Json格式 ERROR == %s"%e)
  216 + return False
  217 +
  218 +
  219 +