接口组合参数压力测试进阶篇

橙子0012

对每组参数采用协程压测的方式进行压测
yaml管理用例
支持登陆成功后返回token或者user_id给其他接口使用,如果接参数需要多个加密参数，留了扩展，
自己去封装
检查点采用检查接口和访问数据库的方式进行检查
如果正常参数直接访问数据库，如果是异常参数直接读取接口返回值
注意此框架暂时还是探索阶段，有什么好想法欢迎提供
常用配置

全局变量

1. PICT_PARAMS = "d:/params.txt" # 请求参数存放地址txt
   
2. PICT_PARAMS_RESULT = "d:/t2.txt" # 参数配对后的路径excel
   
3. # 数据库的常用字段
   
4. FIND_BY_SQL = "findBySql" # 根据sql查找
   
5. COUNT_BY_SQL = "countBySql" # 自定义sql 统计影响行数
   
6. INSERT = "insert" # 插入
   
7. UPDATE_BY_ATTR = "updateByAttr" # 更新数据
   
8. DELETE_BY_ATTR = "deleteByAttr" # 删除数据
   
9. FIND_BY_ATTR = "findByAttr" # 根据条件查询一条记录
   
10. FIND_ALL_BY_ATTR = "findAllByAttr"  #根据条件查询多条记录
    
11. COUNT = "count" # 统计行
    
12. EXIST = "exist" # 是否存在该记录
    
13. #接口简单点中的erro定义
    
14. NORMAL = "0" # 正常参数，可以到表里面找到
    
15. DEFAULT = "1" # 无此参数
    
16. EMPTY = "2" # 参数为空值，如name=''
    
17. DROP = "3" # 数据库中找不到此参数
    
18. # 接口统计
    
19. LOGIN_KEY = ""  # 登陆后返回的key
    
20. LOGIN_VALUE = ""  # 登陆后返回的value
    
21. RESULT = {"info": []} # 存最后结果
    
22. api.yaml
    
23. ---
    
24. title: XXXX接口测试
    
25. host: rap.taobao.org
    
26. port: 80
    
27. protocol: http://
    
28. header: {"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8","User-Agent":"Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36"}
    
29. database: {"databaseName":userinfo,"host":"127.0.0.1", "user": "root", "password": "", "port": 3306, "charset": "utf8"} #配置数据库
    
30. api_list:
    
31. - id: 1001
    
32.   name: 登陆
    
33.   method: post
    
34.   url: /mockjs/11463/login
    
35.   stress: 2
    
36.   hope_sql: {"findKey": "findBySql", "sql": "select * from info", "params": { }} #注意findKey的值，要对应全局变量里面的值
    
37.   params:
    
38.   - "user_name:user_name:error:0:send_keys:333:type:str,user_name:error:1,user_name:error:2,user_name:error:3:send_keys:22222:type:str"
    
39.   - "pwd:pwd:error:0:send_keys:111:type:str,pwd:error:1,pwd:error:2,pwd:error:3:send_keys:32321:type:str"
    
40.   # 注意这里的error,对应全局变量里面的error
    
41.   is_first: 1 # 预览的登陆接口
    
42.   login_key: user_id # 返回给其他接口使用的key
    
43. - id: 1002
    
44.   ...
    
45.   get_login_param: 1 # 需要登陆接口返回过来的参数

复制代码

核心代码分析

入口代码

1. from DAL import httpConfig as hc
   
2. from DAL import gevents, dbConnection, httpParams
   
3. from common import operateYaml
   
4. from DAL.pairs import *
   
5. PATH = lambda p: os.path.abspath(
   
6.     os.path.join(os.path.dirname(__file__), p)
   
7. )
   
8. def myRequest(**kwargs):
   
9.   # {"appStatus": {"errorCode": 0,"message": "操作成功"},"content": {"nickname":"1212121","user_id": 30}} 接口定义的规则
   
10.   # 现在只是考虑到了登陆后返回token,user_id这方面的需求
    
11. 
    
12.     method = kwargs["param_req"]["method"]
    
13.     get_login_params = 0 # 标识接受了返回多少个参数（user_id,token），用作后面拓展
    
14.     param = httpParams.params_filter(kwargs["param_result"])  # 请求参数的处理，如果这里有各种加密可从此处扩展
    
15.     # get_login_param表示此接口需要登陆返回来的id(token),一般登陆成功后返回的字段
    
16.     if kwargs["param_req"].get("is_first", "false") == "false" and kwargs["param_req"].get("get_login_param", "false") != "false":
    
17.         param[Const.LOGIN_KEY]= Const.LOGIN_VALUE
    
18.         get_login_params += 1
    
19.     if kwargs["param_req"]["method"] == Const.HTTP_POST:
    
20.         really_result = kwargs["http_config"].post(dict_post=kwargs["param_req"], param=param) # 发送post请求
    
21.     elif kwargs["param_req"]["method"] == Const.HTTP_GET:
    
22.         really_result = kwargs["http_config"].get(dict_get=kwargs["param_req"], param=param)  # 发送get请求
    
23.     if really_result.get("status_code") == 200:
    
24.         print("请求%s成功鸟" %method)
    
25.         if kwargs["param_req"].get("is_first", "false") != "false" :
    
26.             # 需要接口返回过来的login_key，如token,user_id）等，此时就不用查数据库作为检查点，检查点为直接读取响应结果
    
27.             if really_result["appStatus"]["errorCode"] == 0:
    
28.                 Const.LOGIN_KEY = kwargs["param_req"]["login_key"]
    
29.                 Const.LOGIN_VALUE = really_result["content"][Const.LOGIN_KEY]
    
30.                 print("%s接口验证通过,不查数据库" %method)
    
31.                 kwargs["result"]["success"] += 1
    
32.             else:
    
33.                 print("%s接口测试失败,不查数据库~" %method)
    
34.                 kwargs["result"]["failed"] += 1
    
35. 
    
36.         #如果实际的参数是异常,is_first表示是非登陆接口，就不查数据库.
    
37.         elif len(kwargs["param_result"].keys()) != len(param) - get_login_params:
    
38.             #根据接口返回的errorCode判断，假如errorCode=2表示参数异常
    
39.             if really_result["appStatus"]["errorCode"] == 2:
    
40.                 print("%s接口异常参数检测通过" % method)
    
41.                 kwargs["result"]["success"] += 1
    
42.             else:
    
43.                 print("%s接口异常参数检测失败" % method)
    
44.                 kwargs["result"]["failed"] += 1
    
45.             return
    
46.         else: #直接查询数据库作为检查点
    
47.             check_sql_key = kwargs["param_req"]["hope_sql"]["findKey"]  # 根据这里的key,来跳转到不同的数据库查询语句
    
48.             kwargs["param_req"]["hope_sql"]["params"] = param  # 已经处理好的请求参数传给数据库sql语句参数，结果为：params{"a":"b"}
    
49.             for item in kwargs["param_result"]:
    
50.                 #  error: 0正常，1无此参数，2参数的值为空，3在数据库中不存.0和3查数据库，1,2直接读取接口返回信息
    
51.                 error = kwargs["param_result"][item]["error"]
    
52.                 if error == Const.NORMAL or error == Const.DROP:
    
53.                     if kwargs["check_sql"].findKeySql(check_sql_key, **kwargs["param_req"]["hope_sql"]):
    
54.                         print("%s数据库接口验证成功" %method)
    
55.                         kwargs["result"]["success"] += 1
    
56.                     else:
    
57.                         print("%s数据库接口验证失败" %method)
    
58.                         kwargs["result"]["failed"] += 1
    
59.                     return
    
60.                 elif error == Const.DEFAULT or error == Const.EMPTY:
    
61.                     if really_result["appStatus"]["errorCode"] == 2: # 接口返回的2为参数异常
    
62.                         print("%s接口异常参数检测成功" %method)
    
63.                         kwargs["result"]["success"] += 1
    
64.                     else:
    
65.                         print("%s接口异常参数检测失败" % method)
    
66.                         kwargs["result"]["failed"] += 1
    
67.                     return
    
68.     else:
    
69.         print("请求发送失败,状态码为:%s" % really_result.get("status_code"))
    
70. def gevent_request(**kwargs):
    
71.     for i in kwargs["api_config"]:  # 读取各个接口的配置，api.ymal
    
72.         # 生成参数
    
73.         pict_param(params=i["params"], pict_params=Const.PICT_PARAMS,
    
74.                    pict_params_result=Const.PICT_PARAMS_RESULT)
    
75.         # 读取参数
    
76.         get_param = read_pict_param(Const.PICT_PARAMS_RESULT)
    
77.         count = len(get_param) # 根据不同分组参数，循环请求
    
78.         green_let = []
    
79.         req = {}
    
80.         for key in i:
    
81.             if key != "params":  # 过滤请求参数，参数上面已经处理好了
    
82.                 req[key] = i[key]
    
83.         result = {}  # 统计数据
    
84.         result["name"] = req["name"]  # 接口名字
    
85.         result["method"] = req["method"]
    
86.         result["url"] = req["url"]
    
87.         result["sum"] = count
    
88.         result["stress"] = req["stress"]
    
89.         result["success"] = 0
    
90.         result["failed"] = 0
    
91.         kwargs["result"] = result
    
92.         for k in range(0, count):
    
93.             kwargs["param_result"] = get_param[k]  # 接口中不同的参数组合，是dict类型
    
94.             kwargs["param_req"] = req  #每次请求除组合参数之外的参数，如逾期只，请求的url,method,结束等
    
95.             for item in range(kwargs["param_req"]["stress"]):  # 压力测试,启动协程去压测
    
96.                 green_let.append(gevents.requestGevent(myRequest(**kwargs)))
    
97.             for k in range(0, kwargs["param_req"]["stress"]):
    
98.                 green_let[k].start()
    
99.             for k in range(0, kwargs["param_req"]["stress"]):
    
100.                 green_let[k].join()
     
101.         Const.RESULT["info"].append(kwargs["result"])
     
102. def get_config(api_ymal):
     
103.     '''
     
104.     得到api.ymal中的设置的接口信息
     
105.     :param api_ymal:
     
106.     :return:
     
107.     '''
     
108.     http_config = {} # http信息的记录
     
109.     api_config = [] # api的记录记录
     
110.     get_api_list = operateYaml.getYam(api_ymal)
     
111.     for key in get_api_list:
     
112.         if type(get_api_list[key]) != list:
     
113.             http_config[key] = get_api_list[key]
     
114.         else:
     
115.             api_config = get_api_list[key]
     
116.     return http_config, api_config
     
117. 
     
118. 
     

复制代码

橙子0012

1. if __name__ == "__main__":
   
2. start_time = time.time()
   
3. get_api_config = get_config(PATH("api.ymal"))
   
4. http_conf = hc.ConfigHttp(dict_http=get_api_config[0]) # http请求的设置
   
5. apiConfigs = get_api_config[1]
   
6. check_sql = dbConnection. MySQLet(host=get_api_config[0]["database"]["host"], user=get_api_config[0]["database"]["user"],
   
7. password=get_api_config[0]["database"]["password"], charset=get_api_config[0]["database"]["charset"],
   
8. database=get_api_config[0]["database"]["databaseName"], port=get_api_config[0]["database"]["port"])
   
9. gevent_request(http_config=http_conf, api_config=get_api_config[1], check_sql=check_sql)
   
10. check_sql.close()
    
11. end_time = time.time()
    
12. print("共花费：""%.2f" % (end_time - start_time))
    
13. print(Const.RESULT)
    
14. 
    
15. 
    
16. 封装好的访问数据库,查看主要代码来自这里，我修改了一些东西和bug
    
17. import mysql.connector
    
18. import mysql.connector.errors
    
19. from common.customConst import Const
    
20. class MySQLet:
    
21. """Connection to a MySQL"""
    
22. # def __init__(self,user='',password='',database='',charset=None,port=3306):
    
23. def __init__(self,**kwargs):
    
24. try:
    
25. self._conn = mysql.connector.connect(host=kwargs["host"], user=kwargs["user"], password=kwargs["password"],
    
26. charset=kwargs["charset"], database=kwargs["database"], port=kwargs["port"])
    
27. self.__cursor = None
    
28. print("连接数据库")
    
29. #set charset charset = ('latin1','latin1_general_ci')
    
30. except mysql.connector.errors.ProgrammingError as err:
    
31. print('mysql连接错误：' + err.msg)
    
32. 
    
33. # def findBySql(self, sql, params={}, limit=0, join='AND'):
    
34. def findBySql(self, **kwargs):
    
35. """
    
36. 自定义sql语句查找
    
37. limit = 是否需要返回多少行
    
38. params = dict(field=value)
    
39. join = 'AND | OR'
    
40. """
    
41. print("-----------findbysql-----")
    
42. print(kwargs)
    
43. cursor = self.__getCursor()
    
44. # sql = self.__joinWhere(kwargs["sql"], kwargs["params"], kwargs["join"])
    
45. if kwargs.get("join", 0) == 0: kwargs["join"] = "AND"
    
46. if kwargs.get("limit", "0") == "0": kwargs["limit"] = 1
    
47. sql = self.__joinWhere(**kwargs)
    
48. cursor.execute(sql, tuple(kwargs["params"].values()))
    
49. rows = cursor.fetchmany(size=kwargs["limit"]) if kwargs["limit"] > 0 else cursor.fetchall()
    
50. result = [dict(zip(cursor.column_names,row)) for row in rows] if rows else None
    
51. return result
    
52. 
    
53. # def countBySql(self,sql,params = {},join = 'AND'):
    
54. def countBySql(self, **kwargs):
    
55. """自定义sql 统计影响行数"""
    
56. if kwargs.get("join", 0) == 0: kwargs["join"] = "AND"
    
57. cursor = self.__getCursor()
    
58. # sql = self.__joinWhere(kwargs["sql"], kwargs["params"], kwargs["join"])
    
59. sql = self.__joinWhere(**kwargs)
    
60. cursor.execute(sql, tuple(kwargs["params"].values()))
    
61. result = cursor.fetchall() # fetchone是一条记录， fetchall 所有记录
    
62. return len(result) if result else 0
    
63. 
    
64. # def insert(self,table,data):
    
65. def insert(self, **kwargs):
    
66. """新增一条记录
    
67. table: 表名
    
68. data: dict 插入的数据
    
69. """
    
70. fields = ','.join('`'+k+'`' for k in kwargs["data"].keys())
    
71. values = ','.join(("%s", ) * len(kwargs["data"]))
    
72. sql = 'INSERT INTO `%s` (%s) VALUES (%s)' % (kwargs["table"], fields, values)
    
73. cursor = self.__getCursor()
    
74. cursor.execute(sql, tuple(kwargs["data"].values()))
    
75. insert_id = cursor.lastrowid
    
76. self._conn.commit()
    
77. return insert_id
    
78. 
    
79. # def updateByAttr(self,table,data,params={},join='AND'):
    
80. def updateByAttr(self, **kwargs):
    
81. # """更新数据"""
    
82. if kwargs.get("params", 0) == 0:
    
83. kwargs["params"] = {}
    
84. if kwargs.get("join", 0) == 0:
    
85. kwargs["join"] = "AND"
    
86. fields = ','.join('`' + k + '`=%s' for k in kwargs["data"].keys())
    
87. values = list(kwargs["data"].values())
    
88. 
    
89. 
    
90. values.extend(list(kwargs["params"].values()))
    
91. sql = "UPDATE `%s` SET %s " % (kwargs["table"], fields)
    
92. kwargs["sql"] = sql
    
93. sql = self.__joinWhere(**kwargs)
    
94. cursor = self.__getCursor()
    
95. cursor.execute(sql, tuple(values))
    
96. self._conn.commit()
    
97. return cursor.rowcount
    
98. 
    
99. 
    
100. # def updateByPk(self,table,data,id,pk='id'):
     
101. def updateByPk(self, **kwargs):
     
102. """根据主键更新，默认是id为主键"""
     
103. return self.updateByAttr(**kwargs)
     
104. 
     
105. # def deleteByAttr(self,table,params={},join='AND'):
     
106. def deleteByAttr(self, **kwargs):
     
107. """删除数据"""
     
108. if kwargs.get("params", 0) == 0:
     
109. kwargs["params"] = {}
     
110. if kwargs.get("join", 0) == 0:
     
111. kwargs["join"] = "AND"
     
112. # fields = ','.join('`'+k+'`=%s' for k in kwargs["params"].keys())
     
113. sql = "DELETE FROM `%s` " % kwargs["table"]
     
114. kwargs["sql"] = sql
     
115. # sql = self.__joinWhere(sql, kwargs["params"], kwargs["join"])
     
116. sql = self.__joinWhere(**kwargs)
     
117. cursor = self.__getCursor()
     
118. cursor.execute(sql, tuple(kwargs["params"].values()))
     
119. self._conn.commit()
     
120. return cursor.rowcount

复制代码

1. # def deleteByPk(self,table,id,pk='id'):
   
2.     def deleteByPk(self, **kwargs):
   
3.         """根据主键删除，默认是id为主键"""
   
4.         return self.deleteByAttr(**kwargs)
   
5. 
   
6.     # def findByAttr(self,table,criteria = {}):
   
7.     def findByAttr(self, **kwargs):
   
8.         """根據條件查找一條記錄"""
   
9.         return self.__query(**kwargs)
   
10. 
    
11.     # def findByPk(self,table,id,pk='id'):
    
12.     def findByPk(self, **kwargs):
    
13.         return self.findByAttr(**kwargs)
    
14. 
    
15.     # def findAllByAttr(self,table,criteria={}, whole=true):
    
16.     def findAllByAttr(self, **kwargs):
    
17.         """根據條件查找記錄"""
    
18.         return self.__query(**kwargs)
    
19. 
    
20.     # def count(self,table,params={},join='AND'):
    
21.     def count(self, **kwargs):
    
22.         """根据条件统计行数"""
    
23.         if kwargs.get("join", 0) == 0: kwargs["join"] = "AND"
    
24.         sql = 'SELECT COUNT(*) FROM `%s`' % kwargs["table"]
    
25.         # sql = self.__joinWhere(sql, kwargs["params"], kwargs["join"])
    
26.         kwargs["sql"] = sql
    
27.         sql = self.__joinWhere(**kwargs)
    
28.         cursor = self.__getCursor()
    
29.         cursor.execute(sql, tuple(kwargs["params"].values()))
    
30.         result = cursor.fetchone()
    
31.         return result[0] if result else 0
    
32. 
    
33.     # def exist(self,table,params={},join='AND'):
    
34.     def exist(self, **kwargs):
    
35.         """判断是否存在"""
    
36.         return self.count(**kwargs) > 0
    
37. 
    
38.     def close(self):
    
39.         """关闭游标和数据库连接"""
    
40.         if self.__cursor is not None:
    
41.             self.__cursor.close()
    
42.         self._conn.close()
    
43. 
    
44.     def __getCursor(self):
    
45.         """获取游标"""
    
46.         if self.__cursor is None:
    
47.             self.__cursor = self._conn.cursor()
    
48.         return self.__cursor
    
49. 
    
50.     # def __joinWhere(self,sql,params,join):
    
51.     def __joinWhere(self, **kwargs):
    
52.         """转换params为where连接语句"""
    
53.         if kwargs["params"]:
    
54.             keys,_keys = self.__tParams(**kwargs)
    
55.             where = ' AND '.join(k+'='+_k for k,_k in zip(keys,_keys)) if kwargs["join"] == 'AND' else ' OR '.join(k+'='+_k for k,_k in zip(keys,_keys))
    
56.             kwargs["sql"]+=' WHERE ' + where
    
57.         return kwargs["sql"]
    
58. 
    
59.     # def __tParams(self,params):
    
60.     def __tParams(self, **kwargs):
    
61.         keys = ['`'+k+'`' for k in kwargs["params"].keys()]
    
62.         _keys = ['%s' for k in kwargs["params"].keys()]
    
63.         return keys,_keys
    
64. 
    
65.     # def __query(self,table,criteria,whole=False):
    
66.     def __query(self, **kwargs):
    
67.         if kwargs.get("whole", False) == False or kwargs["whole"] is not True:
    
68.             kwargs["whole"] = False
    
69.             kwargs["criteria"]['limit'] = 1
    
70.         # sql = self.__contact_sql(kwargs["table"], kwargs["criteria"])
    
71.         sql = self.__contact_sql(**kwargs)
    
72.         cursor = self.__getCursor()
    
73.         cursor.execute(sql)
    
74.         rows = cursor.fetchall() if kwargs["whole"] else cursor.fetchone()
    
75.         result = [dict(zip(cursor.column_names, row)) for row in rows] if kwargs["whole"] else dict(zip(cursor.column_names, rows)) if rows else None
    
76.         return result
    
77. 
    
78.     # def __contact_sql(self,table,criteria):
    
79.     def __contact_sql(self, **kwargs):
    
80.         sql = 'SELECT '
    
81.         if kwargs["criteria"] and type(kwargs["criteria"]) is dict:
    
82.             #select fields
    
83.             if 'select' in kwargs["criteria"]:
    
84.                 fields = kwargs["criteria"]['select'].split(',')
    
85.                 sql+= ','.join('`'+field+'`' for field in fields)
    
86.             else:
    
87.                 sql+=' * '
    
88.             #table
    
89.             sql+=' FROM `%s`'% kwargs["table"]
    
90.             #where
    
91.             if 'where' in kwargs["criteria"]:
    
92.                 sql+=' WHERE '+ kwargs["criteria"]['where']
    
93.             #group by
    
94.             if 'group' in kwargs["criteria"]:
    
95.                 sql+=' GROUP BY '+ kwargs["criteria"]['group']
    
96.             #having
    
97.             if 'having' in kwargs["criteria"]:
    
98.                 sql+=' HAVING '+ kwargs["criteria"]['having']
    
99.             #order by
    
100.             if 'order' in kwargs["criteria"]:
     
101.                 sql+=' ORDER BY '+ kwargs["criteria"]['order']
     
102.             #limit
     
103.             if 'limit' in kwargs["criteria"]:
     
104.                 sql+=' LIMIT '+ str(kwargs["criteria"]['limit'])
     
105.             #offset
     
106.             if 'offset' in kwargs["criteria"]:
     
107.                 sql+=' OFFSET '+ str(kwargs["criteria"]['offset'])
     
108.         else:
     
109.             sql+=' * FROM `%s`'% kwargs["table"]
     
110.         return sql
     
111.     def findKeySql(self, key ,**kwargs):
     
112.         print("-----------")
     
113.         print(key)
     
114.         sqlOperate = {
     
115.         Const.COUNT: lambda: self.count(**kwargs),
     
116.         Const.COUNT_BY_SQL: lambda: self.countBySql(**kwargs),
     
117.         Const.DELETE_BY_ATTR: lambda: self.deleteByAttr(**kwargs),
     
118.         Const.EXIST: lambda: self.exist(**kwargs),
     
119.         Const.FIND_ALL_BY_ATTR: lambda: self.findAllByAttr(**kwargs),
     
120.         Const.INSERT: lambda: self.insert(**kwargs),
     
121.         Const.FIND_BY_ATTR: lambda: self.findByAttr(**kwargs),
     
122.         Const.UPDATE_BY_ATTR: lambda: self.updateByAttr(**kwargs),
     
123.         Const.FIND_BY_SQL: lambda: self.findBySql(**kwargs)
     
124. 
     
125.         }
     
126. 
     

复制代码

橙子0012

1. return sqlOperate[key]()
   
2. 
   
3. if __name__ == "__main__":
   
4. mysqlet = MySQLet(host="127.0.0.1", user="root", password="", charset="utf8", database="userinfo", port=3306)
   
5. # 根据字段统计count, join>>AND,OR,可以不传，默认为AND
   
6. # print(mysqlet.findKeySql(Const.COUNT, table="info", params={"id": "11", "name": "666"}, join="OR"))
   
7. # # 自定义sql语句统计count
   
8. # print(mysqlet.findKeySql(Const.COUNT_BY_SQL, sql="select * from info", params={"name": "666"}, join="AND"))
   
9. # #插入数据
   
10. # print(mysqlet.findKeySql(Const.INSERT, table="info", data={"name":"333", "pwd": "111"}))
    
11. 测试结果分析
    
12. 现在只是简单的记录下结果，后续优化
    
13. #{'method': 'post', 'success': 32, 'stress': 2, 'failed': 0, 'url': '/mockjs/11463/login', 'name': '登陆', 'sum': 16}
    
14. '''
    
15. sum 表示此接口有16组参数
    
16. stress: 表示每组参数压测两次
    
17. method: 请求方法
    
18. success: 成功请求次数
    
19. failed:失败请求次数
    
20. url:请求的网址
    
21. name:接口名字
    
22. '''

复制代码

梦想家

赞一个辛苦了

louisadt

goog job

Miss_love

支持分享