locust工具学习笔记（五）-FastHttpUser类、关联、参数化、检查点、集合点

最新推荐文章于 2023-11-28 15:50:30 发布
最新推荐文章于 2023-11-28 15:50:30 发布
阅读量4k 收藏 31
点赞数 4
分类专栏： locust 性能测试 软件测试 文章标签： python locust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012002125/article/details/113363768
版权

locust工具学习笔记（五）

FastHttpUser类

locust的HTTP客户端默认是使用requests模块实现的，但是在大规模并发http请求时，requests模块并不是最优的实现，为了解决并发资源消耗问题，locust建议使用faster HTTP client的实现，它使用了geventhttpclient代替了requests. 它能提升5-6倍的并发量。

使用方法就是用FastHttpUser代替HttpUser

#使用HttpUser
from locust import User,HttpUser,task,constant
​
class MyUserBe(HttpUser):
    wait_time = constant(1)
​
    @task
    def my_task1(self):
        with self.client.get("https://www.baidu.com/", catch_response=True) as res:
            if res.status_code == 200:
                print("成功")
            else:
                print("失败")
​
​
class MyUser(User):
    wait_time = constant(1)
    tasks = [MyUserBe]
​
#使用FastHttpUser
from locust.contrib.fasthttp import FastHttpUser
from locust import User,HttpUser,task,constant
​
class MyUserBe(FastHttpUser):
    wait_time = constant(1)
​
    @task
    def my_task1(self):
        with self.client.get("https://www.baidu.com/", catch_response=True) as res:
            if res.status_code == 200:
                print("成功")
            else:
                print("失败")
​
​
class MyUser(User):
    wait_time = constant(1)
    tasks = [MyUserBe]
    
    
    
#输出
H:\2021\PythonProject\Learning>locust -f H:\2021\PythonProject\Learning\locust_demo21.py
[2021-01-24 22:27:12,728] SKY-20210118WDX/INFO/locust.main: Starting web interface at http://0.0.0.0:8089 (accepting connections from all network interfaces)
[2021-01-24 22:27:12,740] SKY-20210118WDX/INFO/locust.main: Starting Locust 1.4.1
[2021-01-24 22:27:31,346] SKY-20210118WDX/INFO/locust.runners: Spawning 5 users at the rate 2 users/s (0 users already running)...
成功
成功
成功
成功
成功
[2021-01-24 22:27:33,351] SKY-20210118WDX/INFO/locust.runners: All users spawned: MyUserBe: 3, MyUser: 2 (5 total running)
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
成功
​

在相同的并发条件下使用FastHttpUser能有效减少对负载机的资源消耗从而达到更大的http请求。

关联

在编写接口脚本时会经常遇到测试的接口需要依赖上一个接口的返回参数作为入参，此时就需要做参数动态关联，在locust中关联的实现方式多种多样，下面是示例代码仅供参考。

#示例1
from locust import TaskSet, task, HttpUser
class UserBehavior(TaskSet):
​
    def on_start(self):
        global token
        token = self.client.get('/login').text
​
    @task
    def login(self):
        payload = { 'username': "xxxxxxxxxxxxxxxx", 'password': 'xxxxxxxx'}
        headers = {"token":token}
        self.client.post('/user', data=payload,headers=headers)
​
class WebUser(HttpUser):
    tasks = [UserBehavior]
    min_wait = 1000
    max_wait = 3000
    
    
#示例2
from locust import TaskSet, task, HttpUser
class UserBehavior(TaskSet):
​
    @task
    def login(self):
        re= self.client.get('/login').text   #比如获取token
        payload = { 'username': "xxxxxxxxxxxxxxxx", 'password': 'xxxxxxxx'}
        headers = {"token":re}
        self.client.post('/user', data=payload,headers=headers)
​
class WebUser(HttpUser):
    tasks = [UserBehavior]
    min_wait = 1000
    max_wait = 3000
​

参数化

压力测试中不可避免需要进行参数化，参数一般情况下有如下几种情况

场景一、所有用户随机取数，数据可以重复使用

  • 示例处理方法：将数据存储在文件中，测试时可读取出来再随机取数

场景二、所有用户顺序循环取数，数据可以重复使用

  • 示例处理方法：将数据存储到队列中，取出一个数据后再将其压入队列中

场景三、所有数据只能用一次，用完即止

  • 示例处理方法：将数据存储到队列中，直接读取直到队列为空

下面只展示使用队列参数化

#场景三、所有数据只能用一次，用完即止
from locust.contrib.fasthttp import FastHttpUser
from locust import User, HttpUser, task, constant
import queue
​
class MyUserBe(FastHttpUser):
    wait_time = constant(1)
    test_data = [111,222,333,444,555,666,777,888,999]   #示例数据源，实际情况一般数据存储在文件或数据库中
    Q= queue.Queue()    #队列中的数据取完后测试就停止了
    def on_start(self):
        for i in self.test_data:
            self.Q.put(i) 
​
​
    @task
    def my_task1(self):
        with self.client.get("https://www.baidu.com/"+str(self.Q.get()), catch_response=True) as res:
            if res.status_code == 200:
                print("成功")
            else:
                print("失败")
​
​
class MyUser(User):
    wait_time = constant(1)
    tasks = [MyUserBe]
​
#执行结果
[2021-01-26 19:41:54,645] 910lanmingyong/INFO/locust.runners: 1 Users have been stopped
 Name                                                          # reqs      # fails  |     Avg     Min     Max  Median  |   req/s failures/s
--------------------------------------------------------------------------------------------------------------------------------------------
 GET https://www.baidu.com/111                                      1   1(100.00%)  |      59      59      59      59  |    0.12    0.12
 GET https://www.baidu.com/222                                      1   1(100.00%)  |      10      10      10      10  |    0.12    0.12
 GET https://www.baidu.com/333                                      1   1(100.00%)  |      10      10      10      10  |    0.12    0.12
 GET https://www.baidu.com/444                                      1   1(100.00%)  |       9       9       9       9  |    0.12    0.12
 GET https://www.baidu.com/555                                      1   1(100.00%)  |      10      10      10      10  |    0.12    0.12
 GET https://www.baidu.com/666                                      1   1(100.00%)  |      10      10      10      10  |    0.12    0.12
 GET https://www.baidu.com/777                                      1   1(100.00%)  |      12      12      12      12  |    0.12    0.12
 GET https://www.baidu.com/888                                      1   1(100.00%)  |      10      10      10      10  |    0.12    0.12
 GET https://www.baidu.com/999                                      1   1(100.00%)  |      11      11      11      11  |    0.12    0.12
--------------------------------------------------------------------------------------------------------------------------------------------
 Aggregated                                                         9   9(100.00%)  |      15       9      59      10  |    1.10    1.10
​
Response time percentiles (approximated)
 Type     Name                                                              50%    66%    75%    80%    90%    95%    98%    99%  99.9% 99.99%   100% # reqs
--------|------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
 GET      https://www.baidu.com/111                                          59     59     59     59     59     59     59     59     59     59     59      1
 GET      https://www.baidu.com/222                                          10     10     10     10     10     10     10     10     10     10     10      1
 GET      https://www.baidu.com/333                                          10     10     10     10     10     10     10     10     10     10     10      1
 GET      https://www.baidu.com/444                                           9      9      9      9      9      9      9      9      9      9      9      1
 GET      https://www.baidu.com/555                                          10     10     10     10     10     10     10     10     10     10     10      1
 GET      https://www.baidu.com/666                                          10     10     10     10     10     10     10     10     10     10     10      1
 GET      https://www.baidu.com/777                                          12     12     12     12     12     12     12     12     12     12     12      1
 GET      https://www.baidu.com/888                                          10     10     10     10     10     10     10     10     10     10     10      1
 GET      https://www.baidu.com/999                                          11     11     11     11     11     11     11     11     11     11     11      1
--------|------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
 None     Aggregated                                                         10     10     11     12     59     59     59     59     59     59     59      9
​
Error report
 # occurrences      Error
--------------------------------------------------------------------------------------------------------------------------------------------
 1                  GET https://www.baidu.com/111: "BadStatusCode('https://www.baidu.com/111', code=404)"
 1                  GET https://www.baidu.com/222: "BadStatusCode('https://www.baidu.com/222', code=404)"
 1                  GET https://www.baidu.com/333: "BadStatusCode('https://www.baidu.com/333', code=404)"
 1                  GET https://www.baidu.com/444: "BadStatusCode('https://www.baidu.com/444', code=404)"
 1                  GET https://www.baidu.com/555: "BadStatusCode('https://www.baidu.com/555', code=404)"
 1                  GET https://www.baidu.com/666: "BadStatusCode('https://www.baidu.com/666', code=404)"
 1                  GET https://www.baidu.com/777: "BadStatusCode('https://www.baidu.com/777', code=404)"
 1                  GET https://www.baidu.com/888: "BadStatusCode('https://www.baidu.com/888', code=404)"
 1                  GET https://www.baidu.com/999: "BadStatusCode('https://www.baidu.com/999', code=404)"
--------------------------------------------------------------------------------------------------------------------------------------------
​

检查点（断言）

在locust测试是否通过默认是通过http的状态码来判断，显然这是这是不能满足实际需求的，这时就需要自定义判断返回值是否符合预期

from locust import task, constant, HttpUser, TaskSet
​
class MyUser1(TaskSet):
    @task
    def task_1(self):
        ##断言方法，要在请求加入参数开启catch_response=True
        with self.client.get('/',catch_response = True) as response:
            #拿到响应后可以通过json形式获取响应值进行断言
            if response.status_code == 200:
                response.success()
            else:
                response.failure("失败")
​
​
class MyUserAll(HttpUser):
    wait_time = constant(1)
    tasks = [MyUser1]

集合点

在实际的压测场景中，经常需要让压力在某一个时间点集中并发测试（如秒杀场景），此时就需要有集合点的概念，让所有用户全部完成初始化后集中发起压力，在locust中可以使用gevent信号量Semaphore 实现。

  • 关于Semaphore

Semaphore对象内部管理一个计数器，该计数器由每个acquire()调用递减，并由每个release()调用递增。计数器永远不会低于零，当acquire()发现计数器为零时，线程阻塞，等待其他线程调用release()。

import time
import datetime
from threading import Semaphore,Thread
​
def test1(index, sem):
    sem.acquire() #计数器-1，当前5个线程到达时计数器就为0，此时会阻塞后面5个线程
    print('{0} is waiting semaphore({1}).'.format( index , datetime.datetime.now().strftime('%Y-%m-%d-%H:%M:%S.%f')))
    time.sleep(2)
    sem.release() #计数器+1，当前面5个调用了release时计数器+1，计数器大于0，此时后面五个线程就可以执行了
    print('{0} is release semaphore({1}).'.format( index , datetime.datetime.now().strftime('%Y-%m-%d-%H:%M:%S.%f')))
​
if __name__ == '__main__':
    sem = Semaphore(5)      #计数器初始值为1
    for i in range(10):
        Thread(target=test1, args=(i, sem)).start()  #启动十个线程调用test1
        
#输出
0 is waiting semaphore(2021-01-28-09:02:17.002715).
1 is waiting semaphore(2021-01-28-09:02:17.002715).
2 is waiting semaphore(2021-01-28-09:02:17.002715).
3 is waiting semaphore(2021-01-28-09:02:17.003745).
4 is waiting semaphore(2021-01-28-09:02:17.004712).
1 is release semaphore(2021-01-28-09:02:19.003464).
0 is release semaphore(2021-01-28-09:02:19.003464).
5 is waiting semaphore(2021-01-28-09:02:19.003464).
6 is waiting semaphore(2021-01-28-09:02:19.003464).
​
2 is release semaphore(2021-01-28-09:02:19.004379).
7 is waiting semaphore(2021-01-28-09:02:19.004379).
3 is release semaphore(2021-01-28-09:02:19.005376).
4 is release semaphore(2021-01-28-09:02:19.005376).
8 is waiting semaphore(2021-01-28-09:02:19.005376).
9 is waiting semaphore(2021-01-28-09:02:19.005376).
​
​
5 is release semaphore(2021-01-28-09:02:21.004049).
6 is release semaphore(2021-01-28-09:02:21.004049).
7 is release semaphore(2021-01-28-09:02:21.005046).
9 is release semaphore(2021-01-28-09:02:21.006047).
8 is release semaphore(2021-01-28-09:02:21.006047).

  • 集合点示例1

#方式一，SequentialTaskSet集合点
'''''''''
示例场景1：
一个购物系统，测试开始10个用户启动完毕后先对浏览商品行为压测持续5次，然后10用户在对支付订单行为进行压测一次，再然后是对创建订单压测2次，最后对退出浏览该商品行为压测2次，循环执行上述步骤
'''
import datetime
from locust import  TaskSet, task, events, SequentialTaskSet, User
from gevent._semaphore import Semaphore
​
​
#创建集合点，当locust实例产生完成时触发（即10用户启动完毕）
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
​
​
def on_hatch_complete(**kwargs):
    all_locusts_spawned.release()
​
​
events.spawning_complete.add_listener(on_hatch_complete)
​
​
def login(self):
    print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'用户登陆！')
​
​
def logout(self):
    print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'用户退出')
​
​
class UserBehavior(SequentialTaskSet):
​
    def on_start(self):
        login(self)
        
    def on_stop(self):
        logout(self)
​
    @task(5)
    def BrowseGoods(self):
        all_locusts_spawned.wait()  # 集合点等待并发
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'浏览商品')
​
    @task(1)
    def PayOrder(self):
        all_locusts_spawned.wait()
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'支付订单')
    @task(2)
    def CreateOrder(self):
        all_locusts_spawned.wait()
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'创建订单')
​
    @task(2)
    def leave(self):
        all_locusts_spawned.wait()
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'退出浏览该商品')
​
​
class WebsiteUser(User):
    tasks = [UserBehavior]
    min_wait = 2000 
    max_wait = 3000 
​
    
    
#输出 
E:\PyProject\Learning>locust -f E:\PyProject\Learning\locusti\locustfile_dome15.py
[2021-01-25 16:52:42,348] 910lanmingyong/INFO/locust.main: Starting web interface at http://0.0.0.0:8089 (accepting connections from all network interfaces)
[2021-01-25 16:52:42,354] 910lanmingyong/INFO/locust.main: Starting Locust 1.3.1
[2021-01-25 16:52:51,332] 910lanmingyong/INFO/locust.runners: Spawning 10 users at the rate 3 users/s (0 users already running)...
2021-01-25 16:52:51.332024用户登录！
2021-01-25 16:52:51.666132用户登录！
2021-01-25 16:52:52.000242用户登录！
2021-01-25 16:52:52.333359用户登录！
2021-01-25 16:52:52.667465用户登录！
2021-01-25 16:52:53.001581用户登录！
2021-01-25 16:52:53.335686用户登录！
2021-01-25 16:52:53.669796用户登录！
2021-01-25 16:52:54.002913用户登录！
[2021-01-25 16:52:54,336] 910lanmingyong/INFO/locust.runners: All users spawned: WebsiteUser: 10 (0 already running)
2021-01-25 16:52:54.336106用户登录！
2021-01-25 16:52:54.336106浏览商品
2021-01-25 16:52:54.336106浏览商品
2021-01-25 16:52:54.337020浏览商品
2021-01-25 16:52:54.337020浏览商品
2021-01-25 16:52:54.337020浏览商品
2021-01-25 16:52:54.337020浏览商品
2021-01-25 16:52:54.337020浏览商品
2021-01-25 16:52:54.337020浏览商品
2021-01-25 16:52:54.338017浏览商品
2021-01-25 16:52:54.338017浏览商品
2021-01-25 16:52:56.352732浏览商品
2021-01-25 16:52:56.365704浏览商品
2021-01-25 16:52:56.412492浏览商品
2021-01-25 16:52:56.488378浏览商品
2021-01-25 16:52:56.494351浏览商品
2021-01-25 16:52:56.541230浏览商品
2021-01-25 16:52:56.633942浏览商品
2021-01-25 16:52:56.938096浏览商品
2021-01-25 16:52:56.971008浏览商品
2021-01-25 16:52:57.030849浏览商品
2021-01-25 16:52:58.610643浏览商品
2021-01-25 16:52:58.744363浏览商品
2021-01-25 16:52:58.841099浏览商品
2021-01-25 16:52:58.855985浏览商品
2021-01-25 16:52:58.985643浏览商品
2021-01-25 16:52:59.091358浏览商品
2021-01-25 16:52:59.254926浏览商品
2021-01-25 16:52:59.300800浏览商品
2021-01-25 16:52:59.767625浏览商品
2021-01-25 16:52:59.941098浏览商品
2021-01-25 16:53:00.843695浏览商品
2021-01-25 16:53:01.121950浏览商品
2021-01-25 16:53:01.289588浏览商品
2021-01-25 16:53:01.317430浏览商品
2021-01-25 16:53:01.341369浏览商品
2021-01-25 16:53:01.376273浏览商品
2021-01-25 16:53:01.420156浏览商品
2021-01-25 16:53:01.594695浏览商品
2021-01-25 16:53:02.005601浏览商品
2021-01-25 16:53:02.559124浏览商品
2021-01-25 16:53:03.047825浏览商品
2021-01-25 16:53:03.482663浏览商品
2021-01-25 16:53:03.638248浏览商品
2021-01-25 16:53:03.708066浏览商品
2021-01-25 16:53:03.781866浏览商品
2021-01-25 16:53:03.901628浏览商品
2021-01-25 16:53:04.046166浏览商品
2021-01-25 16:53:04.281540浏览商品
2021-01-25 16:53:04.292506浏览商品
2021-01-25 16:53:05.463473浏览商品
2021-01-25 16:53:05.894246支付订单
2021-01-25 16:53:05.967051支付订单
2021-01-25 16:53:06.028888支付订单
2021-01-25 16:53:06.171506支付订单
2021-01-25 16:53:06.176580支付订单
2021-01-25 16:53:06.315120支付订单
2021-01-25 16:53:06.443777支付订单
2021-01-25 16:53:06.514594支付订单
2021-01-25 16:53:06.777981支付订单
2021-01-25 16:53:08.304909支付订单
2021-01-25 16:53:08.594052创建订单
2021-01-25 16:53:08.712739创建订单
2021-01-25 16:53:08.780577创建订单
2021-01-25 16:53:08.783574创建订单
2021-01-25 16:53:08.822527创建订单
2021-01-25 16:53:08.873307创建订单
2021-01-25 16:53:08.907220创建订单
2021-01-25 16:53:09.068814创建订单
2021-01-25 16:53:09.322112创建订单
2021-01-25 16:53:10.751311创建订单
2021-01-25 16:53:10.787211创建订单
2021-01-25 16:53:10.905898创建订单
2021-01-25 16:53:11.054574创建订单
2021-01-25 16:53:11.155234创建订单
2021-01-25 16:53:11.442466创建订单
2021-01-25 16:53:11.640936创建订单
2021-01-25 16:53:11.747722创建订单
2021-01-25 16:53:11.828441创建订单
2021-01-25 16:53:12.159561创建订单
2021-01-25 16:53:13.046198退出浏览该商品
2021-01-25 16:53:13.295534退出浏览该商品
2021-01-25 16:53:13.540958退出浏览该商品
2021-01-25 16:53:13.673555退出浏览该商品
2021-01-25 16:53:13.910895创建订单
2021-01-25 16:53:14.009716退出浏览该商品
2021-01-25 16:53:14.283902退出浏览该商品
2021-01-25 16:53:14.330777退出浏览该商品
2021-01-25 16:53:14.396602退出浏览该商品
2021-01-25 16:53:14.608036退出浏览该商品
2021-01-25 16:53:15.314155退出浏览该商品
2021-01-25 16:53:15.799861退出浏览该商品
2021-01-25 16:53:15.906577退出浏览该商品
2021-01-25 16:53:16.109038退出浏览该商品
2021-01-25 16:53:16.240771退出浏览该商品
2021-01-25 16:53:16.284574退出浏览该商品
2021-01-25 16:53:16.606716退出浏览该商品
2021-01-25 16:53:16.736371退出浏览该商品
2021-01-25 16:53:17.241097退出浏览该商品
2021-01-25 16:53:17.244089退出浏览该商品
2021-01-25 16:53:17.386635浏览商品
2021-01-25 16:53:17.801614浏览商品
2021-01-25 16:53:18.440832浏览商品
2021-01-25 16:53:18.608382浏览商品
2021-01-25 16:53:18.645312浏览商品
2021-01-25 16:53:18.720084退出浏览该商品
2021-01-25 16:53:18.889636浏览商品
2021-01-25 16:53:19.339434浏览商品
2021-01-25 16:53:19.556883浏览商品
2021-01-25 16:53:19.742362浏览商品
[2021-01-25 16:53:20,027] 910lanmingyong/INFO/locust.runners: Stopping 10 users
2021-01-25 16:53:20.029597用户退出登录！
2021-01-25 16:53:20.029597用户退出登录！
2021-01-25 16:53:20.029597用户退出登录！
2021-01-25 16:53:20.029597用户退出登录！
2021-01-25 16:53:20.030594用户退出登录！
2021-01-25 16:53:20.030594用户退出登录！
2021-01-25 16:53:20.030594用户退出登录！
2021-01-25 16:53:20.030594用户退出登录！
2021-01-25 16:53:20.030594用户退出登录！
2021-01-25 16:53:20.031591用户退出登录！
​

  • 集合点示例2

#方式二，TaskSet集合点
'''''''''
场景1：
一个购物系统，压力测试需要并发10个人，其中有80%人正在浏览商品；20%个人正在支付订单
'''
import datetime
from locust import  TaskSet, task, events, SequentialTaskSet, User
from gevent._semaphore import Semaphore
​
'''''''''
创建集合点，当locust实例产生完成时触发
'''
all_locusts_spawned = Semaphore()
all_locusts_spawned.acquire()
​
​
def on_hatch_complete(**kwargs):
    all_locusts_spawned.release()  
​
events.spawning_complete.add_listener(on_hatch_complete)
​
def login(self):
    print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'用户正在登录！')
    
def logout(self):
    print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'用户正在退出登录！')
​
class UserBehavior(TaskSet):
​
    # 初始化
    def on_start(self):
        login(self)
​
    # 退出测试
    def on_stop(self):
        logout(self)
​
    @task(4) 
    def BrowseGoods(self):
        all_locusts_spawned.wait()  # 集合点等待并发
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'用户浏览商品')
​
    @task(1)
    def PayOrder(self):
        all_locusts_spawned.wait()  # 集合点等待并发
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')+'用户支付订单')
​
​
​
class WebsiteUser(User):
    tasks = [UserBehavior]
    min_wait = 2000 
    max_wait = 3000  
​
​
#设置10个并发用户，当10个用户启动完成是，启动集合点并发
E:\PyProject\Learning>locust -f E:\PyProject\Learning\locusti\locustfile_dome16.py
[2021-01-25 19:16:35,091] 910lanmingyong/INFO/locust.main: Starting web interface at http://0.0.0.0:8089 (accepting connections from all network interfaces)
[2021-01-25 19:16:35,097] 910lanmingyong/INFO/locust.main: Starting Locust 1.3.1
[2021-01-25 19:16:43,464] 910lanmingyong/INFO/locust.runners: Spawning 10 users at the rate 3 users/s (0 users already running)...
2021-01-25 19:16:43.465551用户登录！
2021-01-25 19:16:43.798661用户登录！
2021-01-25 19:16:44.132774用户登录！
2021-01-25 19:16:44.466966用户登录！
2021-01-25 19:16:44.800993用户登录！
2021-01-25 19:16:45.135176用户登录！
2021-01-25 19:16:45.468208用户登录！
2021-01-25 19:16:45.801323用户登录！
2021-01-25 19:16:46.134436用户登录！
[2021-01-25 19:16:46,469] 910lanmingyong/INFO/locust.runners: All users spawned: WebsiteUser: 10 (0 already running)
2021-01-25 19:16:46.470539用户登录！
#第一批        
2021-01-25 19:16:46.471537浏览商品
2021-01-25 19:16:46.472532浏览商品
2021-01-25 19:16:46.472532浏览商品
2021-01-25 19:16:46.472532浏览商品
2021-01-25 19:16:46.472532浏览商品
2021-01-25 19:16:46.473526浏览商品
2021-01-25 19:16:46.473526浏览商品
2021-01-25 19:16:46.473526浏览商品
2021-01-25 19:16:46.473526支付订单
2021-01-25 19:16:46.473526浏览商品
#第二批           
2021-01-25 19:16:48.510174浏览商品
2021-01-25 19:16:48.514084浏览商品
2021-01-25 19:16:48.593875浏览商品
2021-01-25 19:16:48.660696浏览商品
2021-01-25 19:16:48.866149浏览商品
2021-01-25 19:16:48.885175支付订单
2021-01-25 19:16:49.006775支付订单
2021-01-25 19:16:49.115483浏览商品
2021-01-25 19:16:49.168430浏览商品
2021-01-25 19:16:49.252119浏览商品
#第三批         
2021-01-25 19:16:50.589570浏览商品
2021-01-25 19:16:50.985495浏览商品
2021-01-25 19:16:51.109166浏览商品
2021-01-25 19:16:51.159032浏览商品
2021-01-25 19:16:51.251786浏览商品
2021-01-25 19:16:51.290764浏览商品
2021-01-25 19:16:51.359574浏览商品
2021-01-25 19:16:51.662686浏览商品
2021-01-25 19:16:51.666675浏览商品
2021-01-25 19:16:51.684631浏览商品
...        
2021-01-25 19:16:53.297329浏览商品
2021-01-25 19:16:53.377116支付订单
2021-01-25 19:16:53.436043支付订单
2021-01-25 19:16:53.443025浏览商品
2021-01-25 19:16:53.448011浏览商品
2021-01-25 19:16:53.718203浏览商品
2021-01-25 19:16:53.723212浏览商品
2021-01-25 19:16:53.796996浏览商品
2021-01-25 19:16:54.158033浏览商品
2021-01-25 19:16:54.352510浏览商品
2021-01-25 19:16:55.809662浏览商品
2021-01-25 19:16:55.892477浏览商品
2021-01-25 19:16:55.911358浏览商品
2021-01-25 19:16:56.011172浏览商品
2021-01-25 19:16:56.017071支付订单
2021-01-25 19:16:56.222528浏览商品
2021-01-25 19:16:56.240479浏览商品
2021-01-25 19:16:56.442938支付订单
[2021-01-25 19:16:56,553] 910lanmingyong/INFO/locust.runners: Stopping 10 users
2021-01-25 19:16:56.554638用户退出登录！
2021-01-25 19:16:56.554638用户退出登录！
2021-01-25 19:16:56.554638用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！
2021-01-25 19:16:56.555634用户退出登录！

欢迎大家关注我的订阅号，会定期分享一些关于测试相关的文章，有问题也欢迎一起讨论学习！
在这里插入图片描述

小黑测试员
关注
  • 4
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
游戏服务器压测工具locust-支持socket,websocket压测
05-11
python loust压测框架下进行开发支持websocket和socket协议的压测,可分布式测试,通信协议目前用的是skynet的sproto,有需要可以自行更换，游戏开发过程中自己开发工具可用，需懂python,相关库安装已经放到README.md中
Locust工具学习(四)-Taskset嵌套子类，FastHttpUser介绍，HttpUser介绍
七恋的博客
04-18 3413
Taskset嵌套子类，FastHttpUser介绍，HttpUser介绍
docker-locust：Locust.io开源负载测试工具的Docker映像
02-06
码头蝗虫 该项目的目的是提供易于使用的版本，该版本还包含所需的其他/有用的功能。 建筑 Docker-Locust容器可以以4种不同的角色启动： master ：运行Locust的Web界面，您可以在其中启动和停止负载测试并查看实时统计信息。 slave ：模拟用户并根据用户参数攻击目标URL。 controller ：以自动模式协调母版，并在测试结束后下载报告。 standalone ：在本地自动启动上述组件。 支持2种运行类型： 手动：当用户通过Locust Master UI手动启动和停止测试时。 自动：由控制器启动测试并运行指定的时间间隔时。 有两种部署方式： 本地
Locust负载测试工具-其他
06-11
Locust 是一个开源负载测试工具。使用 Python 代码定义用户行为，也可以仿真百万个用户。 Locust 是非常简单易用，分布式，用户负载测试工具。Locust 主要为网站或者其他系统进行负载测试，能测试出一个系统可以并发处理多少用户。 Locust 是完全基于时间的，因此单个机器支持几千个并发用户。相比其他许多事件驱动的应用，Locust 不使用回调，而是使用轻量级的处理方式 gevent。 特性： 1、使用纯 Python 代码编写用户测试场景；不需要 UIs 或者 XML 2、分布式&可伸缩 - 支持成千上万的用户 3、基于 Web 的 UI 4、可以测试任意系统；虽然 Locust 是面向 Web 的，但是也可以测试其他任意的系统
locust压测mqtt
dream_back的博客
09-16 956
locust可以实现模拟大批量用户，并且跟踪每个用户的请求数量、失败数、平均响应时间，jmeter就没有这个效果，只是一个汇总的测试结果，并且locust适合mqtt这种千、万级请求，jmeter性能就没有这么强
locust学习教程（6）- 使用更快的http客户端：FastHttpUser
m0_70618214的博客
06-21 490
Locust 的默认 HTTP 客户端使用的是 python-requests 库。所以，自己电脑12个节点全开的情况下， （1）12节点全开，电脑CPU不过载，9000并发以下的时候使用httpuser （2）12节点全开，电脑CPU过载了，9000并发以上了，考虑使用FastHttpUsers （3）12节点全开，电脑CPU过载了，并发超过6万了，拓展节点机器继续分布式压测，比如这里同事电脑的CPU总共12核，就可以开启12个节点，最大化利用CPU资源，增加电脑发给服务器的每秒的请求数。
【Locust】使用FastHttpUser提高Locust性能
Heney33的博客
04-28 1957
如何提高Locust性能
locust（三）使用更快的FastHttpUser 提高性能
fudacaitao的博客
03-21 7153
Locust’s default HTTP client uses python-requests. It provides a nice API that many python developers are familiar with, and is very well-maintained. But if you’re planning to run tests with very high throughput and have limited hardware for running Locust
locust学习总结6 - 使用更快的http客户端：FastHttpUser
因热爱而坚持，因坚持而愈发热爱。
05-29 1115
FastHttpUser 的使用场景介绍
性能测试Locust--(7)使用更快的HTTP client提高Locust性能
软测小生
02-21 2743
Locust默认的HTTP客户端使用python-requests。因为requests是一个维护良好的python程序包，它提供了许多python开发人员都熟悉的优质API。因此，在许多情况下，建议使用使用请求的默认HttpLocust。 但是，如果计划运行大规模的测试，Locust提供了一个替代的HTTP 客户端 FastHttpLocust，它使用geventhttpclient而不是req...
Python库 | locust_plugins-2.0-py3-none-any.whl
05-07
资源分类：Python库 所属语言：Python 资源全名：locust_plugins-2.0-py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
docs-locust-io-en-0.13.5.pdf
12-11
locust 0.13.5 官网的文档 - locust 0.13.5 官网的文档 - locust 0.13.5 官网的文档
locust实战教程2-测试需求拆解和代码设计
weixin_42030998的博客
09-10 333
本来是想从项目的业务模型来慢慢介绍到需求拆解的，但是转念一想：作为测试人员，自己应该清楚每个人都测试过好多项目，对于我们来说，项目都是大同小异的，具体到测试时都是按功能点划分的，既然这样，那我就按照写测试用例的方式将需求拆解并组织代码设计，这样更加符合测试人员的习惯。【具体流程不会一个个去讲，这样太啰嗦了，会调出典型的来解读，其他的都大同小异】 一、下面4点太长可不看，可以看后面具体会实现哪些功能 1、测试数据准备和清理，即tear_up和tear_down 即要模拟创...
locust实战教程4-登录
weixin_42030998的博客
09-13 528
准备工作 首先需要接近两个问题： 1、用什么发请求（目前是http） 2、测试结果的统计（如响应时间，失败次数，表格等等），毕竟有清晰的结果统计和展示，对于性能的分析十分有参考意义 先从一个简单的例子看下这两个问题怎样解决，以经典的访问百度为例 demo.py from locust import task, SequentialTaskSet from locust.contrib.fasthttp import FastHttpUser import time, requests cla
LOCUST性能测试3（高并发、参数关联、集合点）
Song_Lun的博客
11-25 2038
高并发 FastHttpUser类 locust的HTTP客户端默认是使用requests模块实现的，但是在大规模并发http请求时，requests模块并不是最优的实现，为了解决并发资源消耗问题，locust建议使用faster HTTP client的实现，它使用了geventhttpclient代替了requests. 它能提升5-6倍的并发量。 使用方法就是用FastHttpUser代替HttpUser from locust import TaskSet, task, between from l
locust---详细使用HttpUser写压测请求（时间间隔、任务权重、前置、后置）（二）
最新发布
qq_43461574的博客
11-28 449
设置完成后开始执行。上一节，我们只是做了一个简单的示例，讲了如何使用HTTP请求压测，实际使用情况更复杂，比如压测时，大部分接口需要先登录（不同用户），再查询数据或者其他操作，操作后再退出登录，而且模拟真实用户请求时，用户不可能一直在请求接口，而是操作后等待几秒后再操作，这些我们下面代码都可以实现。如果不设置wait_time，启动参数和之前一样，虚拟用户是5，每秒启动1个用户，持续运行10s，执行的请求是几千个，没有间隔等待时间，会一直不间断执行。
Locust学习记录2-locust用户类属性【HttpUser，wait_time,weight和fixed_count】
weixin_34322964的博客
12-05 542
Locust的用户类属性
性能测试---locust HttpUser 类和@task任务
weixin_44688529的博客
06-22 280
@task接受一个可选的权重参数，可用于指定任务的执行率如下，task2被先选中执行的几率更大 二、HttpUser 类 HttpUser是最常用的User ,添加了一个client用于发出 HTTP 请求的属性client是一个实例HttpSession ,像requests.Session，它在请求之间保留 cookie，可以保持登录状态代码如下（示例）：......
团队管理之绩效考核（OKR、KPI）
热门推荐
u012002125的博客
01-22 1万+
绩效考核（performance examine）：绩效考核是指企业在既定的战略目标下，运用特定的标准和指标，对员工的工作行为及取得的工作业绩进行评估，并运用评估的结果对员工将来的工作行为和工作业绩产生正面引导的过程和方法。 一、绩效考核的方法 KPI （Key Performance Indicator） 关键业绩指标法 OKR （Objectives and Key Results）目标与关键成果法 BSC（Balanced Score Card） 平衡记分卡 本篇只介绍KPI 与 OKR
pip install locust 时报 subprocess-exited-with-error
11-21
当使用pip安装locust时，出现subprocess-exited-with-error错误可能是由于setuptools版本过低导致的。解决方法是先更新setuptools的版本，然后再进行locust的安装。具体步骤如下： 1. 更新setuptools的版本： ```shell pip install --upgrade setuptools ``` 2. 安装locust： ```shell pip install locust ``` 这样就可以成功安装locust了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值