性能测试学习-执行测试脚本，监控性能指标

1、关于使用pymatlab库实现对数据表的增加，获取指定列操作，并在另一个py文件中调用

cursor游标的使用

"""
实现数据连接，并操作数据库，生成随机的用户数据
使用游标
"""
import random

import pymysql

#数据库新增
def insert_db():
    #建立数据库连接
    connect=pymysql.connect(
        host='localhost',  # 主机名（或IP地址）
        port=3306,  # 端口号，默认为3306
        user='root',  # 用户名
        password='123456',  # 密码
        database="woniusalesnew",
        charset='utf8'  # 设置字符编码

    )
    #游标，获取整个数据集
    cur=connect.cursor()
    #循环  生成10行数据，出现在连接的数据表中
    for i in range(10):
        username=random.choice(["xiaolong","xaioming","xiaoli"])+str(random.randint(1,100))
        password=random.choice(["xiaolong","xaioming","xiaoli"])+str(random.randint(1,100))
        realname=random.choice(["xiaolong","xaioming","xiaoli"])+str(random.randint(1,100))
        phone=random.choice(["130","120","139"])+str(random.randint(11111111,99999999))
        role=random.choice(["boss","clert","admin"])

        #驱动数据集
        cur.execute(f"insert into user(username,password,realname,phone,role,createtime) values('{username}','{password}','{realname}','{phone}','{role}','2017-10-01 08:18:20')")
    connect.commit()
    #游标的关闭
    cur.close()
    #连接的关闭
    connect.close()


#数据库查询
def query_db():
    connect=pymysql.connect(
        host='localhost',  # 主机名（或IP地址）
        port=3306,  # 端口号，默认为3306
        user='root',  # 用户名
        password='123456',  # 密码
        database="woniusalesnew",
        charset='utf8'  # 设置字符编码

    )
    #游标，获取整个数据集
    cur=connect.cursor()
    # 驱动数据集
    cur.execute("select username,password from user")
    #获取驱动集合
    tup=cur.fetchall()
    #打印结果
    #print(tup)
    connect.commit()
    #游标的关闭
    cur.close()
    #连接的关闭
    connect.close()
    #返回获得的集合，便于在多线程中调用
    return tup


if __name__ == '__main__':
    #insert_db()
    query_db()

1、问题

浏览器在主请求加载过程中会自动发送一些加载请求,怎么获得这些请求，并用使用http协议+request请求进行性能测试

方法：

1、正则模块匹配出需要的字符，组成一个集合

2、循环该集合

（1）拼接这些匹配出来的字符，构成完整的url

（2）使用get方法，访问这个请求

import re
import requests
lochost='172.22.205.254'

class DEMO:

def __init__(self):
       self.session=requests.session()

def gethomepage(self):
        url=f"http://{lochost}:8080/woniusales/"
        res = self.session.get(url=url)
        print(res)
        #获得图片,js,背景图等加载资源
        js_li = re.findall('type="text/javascript" src="(.+?)"',res.text)
        img_li = re.findall('img src="(.+?)"', res.text)
        backage_i = re.findall('backage-img:url\(\'(.+?)\'\)',res.text)
        url_i=js_li +img_li+backage_i
        for uri in js_li:
            url_i=f"http://{lochost}:8080"+uri
            self.session.get(url=url_i)

def main_test(self):
    for i in range(1):
       self.gethomepage()


if __name__ == '__main__':
    re1 = DEMO()
    re1.main_test()

2、问题

模拟缓存，一些加载请求经常会用到，如何通过缓存获取这些资源而非服务器

方法：

将问题1中匹配获得的url,缓存到一个列表中，如果是第一次的访问请求，就使用服务器，否则就使用列表中的缓存

import re
import requests
lochost='172.22.205.254'
#用于缓存非主请求的url
url_list = []
#创建类
class DEMO:

    def __init__(self):
        self.session=requests.session()

    #获取首页的请求
    def gethomepage(self):
        url=f"http://{lochost}:8080/woniusales/"
        res = self.session.get(url=url)
        print(res)
        #获得图片,js,背景图等加载资源
        js_li = re.findall('type="text/javascript" src="(.+?)"',res.text)
        img_li = re.findall('img src="(.+?)"', res.text)
        backage_i = re.findall('backage-img:url\(\'(.+?)\'\)',res.text)
        #组合
        url_li = js_li + img_li + backage_i
        for uri in url_li:
            url_i = f"http://{lochost}:8080" + uri
            #如果是第一次访问，通过服务器访问请求
            if url_i not in url_list:
                self.session.get(url=url_i)
                #将url缓存
                url_list.append(url_i)

def main_test(self):
    for i in range(1):
       self.gethomepage()


if __name__ == '__main__':
    re1 = DEMO()
    re1.main_test()

3、监控性能指标：响应时间，响应大小（字节）

import re
import requests
import time
lochost='172.22.205.254'
#用于缓存非主请求的url
url_list = []
#创建类
class DEMO:

    def __init__(self):
        self.session=requests.session()

    #获取首页的请求
    def gethomepage(self):
        t1=time.time()
        url=f"http://{lochost}:8080/woniusales/"
        res = self.session.get(url=url)
        print(res)
        #获得图片,js,背景图等加载资源
        js_li = re.findall('type="text/javascript" src="(.+?)"',res.text)
        img_li = re.findall('img src="(.+?)"', res.text)
        backage_i = re.findall('backage-img:url\(\'(.+?)\'\)',res.text)
        #组合
        url_li = js_li + img_li + backage_i
        for uri in url_li:
            url_i = f"http://{lochost}:8080" + uri
            #如果是第一次访问，通过服务器访问请求
            if url_i not in url_list:
                self.session.get(url=url_i)
                #将url缓存
                url_list.append(url_i)
       t2=time.time()
      #运行一次需要的时间
       t=(t2-t1)*1000
       print(f"当前首页获取的响应时间为{t}ms")
        #res.headers类型为字典
       print(f"当前首页获取的响应大小为{ len(res.text + str(res.headers))}B")

def main_test(self):
#通过两次迭代对比，没有缓存和有缓存的区别
    for i in range(2):
       self.gethomepage()


if __name__ == '__main__':
    re1 = DEMO()
    re1.main_test()

4、问题：怎么查看每个功能所用的时间

方法：将每次循环获得的时间放到空的集合中去，最后打印输出

在多用户运行时，主线程会先执行，此时会打印出初始化的空集合；需要使用线程阻塞，保证子线程执行完以后，

"""
基于http协议 通过脚本模拟多线程实现用户的登录，会员新增查看等功能

1、确保单线程接口测试通过
2、再测试以下几种情况
   单用户单迭代
   单用户多迭代   调试数据重复问题
   多用户单迭代   多线程并发问题
   多用户多迭代

思考时间：一个进程与另一个进程之间的时间间隔
"""
import random

import requests
import threading
import time
from PerformanceTest.common import query_db
from PerformanceTest.config import lochost
import re
#用于缓存非主请求的url
url_list = []
#缓存响应时间
time_list=[]
#创建类
class DEMO:

    def __init__(self):
        self.session=requests.session()

    #获取首页的请求
    def gethomepage(self):
        t1=time.time()
        url=f"http://{lochost}:8080/woniusales/"
        res = self.session.get(url=url)
        print(res)
        #获得图片,js,背景图等加载资源
        js_li = re.findall('type="text/javascript" src="(.+?)"',res.text)
        img_li = re.findall('img src="(.+?)"', res.text)
        backage_i = re.findall('backage-img:url\(\'(.+?)\'\)',res.text)
        #组合

        url_li = js_li + img_li + backage_i
        for uri in url_li:
            url_i = f"http://{lochost}:8080" + uri
            #如果是第一次，通过服务器访问请求
            if url_i not in url_list:
                self.session.get(url=url_i)
                #将url缓存
                url_list.append(url_i)
        t2=time.time()
        # 运行一次需要的时间
        t = (t2 - t1) * 1000
        print(f"当前首页获取的响应时间为{t}ms")
        time_list.append(t)
        print(f"当前首页获取的响应大小为{ len(res.text + str(res.headers))}B")



    #登录操作请求
    def login(self,username,password):
        t1 = time.time()
        url="http://172.22.205.254:8080/woniusales/user/login"
        """
        #直接传参
        body = {
            "username": "admin",
            "password": "admin123",
            "verifycode": "0000"
        }
         """
        body={
            "username":username,
            "password":password,
            "verifycode":"0000"
        }
        #通过数据库传参的方式
        body = {
            "username": "admin",
            "password": "admin123",
            "verifycode": "0000"
        }

        res = self.session.post(url=url,data=body)
        print(res.text)
        t2=time.time()
        # 运行一次需要的时间
        t = (t2 - t1) * 1000
        print(f"当前登录获取的响应时间为{t}ms")
        time_list.append(t)

    #进入会员页面请求
    def login_customer(self):
        t1 = time.time()
        url="http://172.22.205.254:8080/woniusales/customer"
        res = self.session.get(url=url)
        if "蜗牛进销存-会员管理" in res.text:
            print("customer is ok")
        else:
            print("customer is ko!")
        t2=time.time()
        # 运行一次需要的时间
        t = (t2 - t1) * 1000
        print(f"当前进入会员页面的响应时间为{t}ms")
        time_list.append(t)


    #会员新增请求
    def add(self):
        t1 = time.time()
        url="http://172.22.205.254:8080/woniusales/customer/add"

        #随机生成用户名，电话号，更符合实际场景
        #random.randint(start,stop)随机生成该范围内的整数
        phone_num=["123","133","155","189",'190']
        customer_phone=random.choice(phone_num)+str(random.randint(11111111,99999999))
        customer_list=["小红","小兰","小黄"]
        customer_name=random.choice(customer_list)
        sex_list=["男","女"]
        sex=random.choice(sex_list)
        body={"customername": customer_name,
              "customerphone":customer_phone,
              "childsex":sex,
              "childdate":"2024-06-22",
              "creditkids":"0",
              "creditcloth":"0"
        }
        custom = self.session.post(url=url,data=body)
        print(custom.text)
        t2 = time.time()
        # 运行一次需要的时间
        t = (t2 - t1) * 1000
        print(f"当前会员新增的响应时间为{t}ms")
        time_list.append(t)

    #查询会员
    def search(self):
        t1 = time.time()
        url="http://172.22.205.254:8080/woniusales/customer/search"
        body={
            "customerphone":"15984908938",
            "page":"1"
        }
        res = self.session.get(url=url,params=body)
        print(res.text)
        t2 = time.time()
        # 运行一次需要的时间
        t = (t2 - t1) * 1000
        print(f"当前查询会员的响应时间为{t}ms")
        time_list.append(t)

    #用户注销请求
    def logout(self):
        t1 = time.time()
        url= "http://172.22.205.254:8080/woniusales/user/logout"
        res = self.session.get(url=url)
        if "尚未登录" in res.text:
            print("logout is ok")
        else:
            print("logout is ko!")
        t2 = time.time()
        # 运行一次需要的时间
        t = (t2 - t1) * 1000
        print(f"当前用户注销的响应时间为{t}ms")
        time_list.append(t)

    #模拟单迭代场景，通过改变range()来实现用户多迭代
    #传入参数
    def main_test(self,username,password):
   # def main_test(self):
   # 进程 通过两次迭代对比，没有缓存和有缓存的时间复杂度区别
     for i in range(4):
       # self.gethomepage()
       #传入参数
        self.login(username,password)
       # self.login()
        self.login_customer()
        self.add()
        self.search()
        self.logout()

if __name__ == '__main__':
    re1 = DEMO()
    #返回数据集生成的用户名和密码数据集
    tup=query_db()
  #re1.main_test()
    #实现多个用户同时使用,有多少个数据集，就循环多少次，取出数据集测试真实用户组
    for i in tup:
        username=i[0]
        password=i[1]
        #注意多线程的使用方法 传入参数
        t= threading.Thread(target= re1.main_test,args=((username,password)))
        t.start()
    #在循环外，否则子线程相互阻塞，要等一个子线程执行完，才会执行下一个；timeout=5000是结果在最后输出
    t.join(timeout=5000)
    print(time_list)