Locust性能自动化—API汇总整理（上）

1、引言

Locust的API共有 15类，如下：

• ① User class
• ② HttpUser class
• ③ TaskSet class
• ④ task decorator
• ⑤ tag decorator
• ⑥ Sequential TaskSet class
• ⑦ Built in wait_time functions
• ⑧ HttpSession class
• ⑨ Response class
• ⑩ ResponseContextManager class
• ⑪ Exceptions
• ⑫ Environment class
• ⑬ Event hooks
• ⑭ Runner classes
• ⑮ Web UI class

关于Locust 的API 内容，由于内容较多，分两篇来分享：

①~⑦：《Locust性能自动化—API汇总整理（上）》

⑧~⑮：《Locust性能自动化—API汇总整理（下）》

2、User class

2.1 定义

class User(environment)

官网原话：

1、Represents a “user” which is to be spawned and attack the system that is to be load tested.
2、The behaviour of this user is defined by its tasks.Tasks can be declared either directly on the class by using the @task decorator on methods, or by setting the tasks attribute.
3、This class should usually be subclassed by a class that defines some kind of client.
For example when load testing an HTTP system, you probably want to use the HttpUser class.

翻译出来就是：

1、使用User进行负载测试。
2、该用户的行为，可以自己定义；可以使用 @task装饰器或者设置 task属性直接在类上声明任务。
3、此类大部分情况都是由定义某种客户端的类继承
例如：在对HTTP系统进行负载测试时， 就会想到使用HttpUser

2.2 类及用法

①abstract=True
若为True，该类则被子类化，并且Locust不会在测试期间产生此类用户

②on_start()：表示开始运行

③on_stop()：表示停止运行

④tasks: List[Union[locust.user.task.TaskSet, Callable]]= []：表示将要运行TaskSet类的集合
如果任务是列表，则随机选择要执行的任务；如果任务是两个元组(可调用，整数)列表，或者是字典，则随机选择要执行的任务，但是会根据其相应的值来对每个任务进行加权。
例如：

class ForumPage(TaskSet):
	#设置权数值
    tasks = {
    	ThreadPage: 20, 
    	write_post: 1
    }
# 可以看出，被选中的 ThreadPage 的可能是 write_post 的20倍。

⑤wait()：设置等待， 在函数 User.wait_time中定义
stop_timeout：禁止 任务中休眠
gevent.sleep()：休眠

⑥wait_time=None：设置等待时间间隔，单位是 秒，可以对单个TaskSet 设置
例如：

from locust import User,between

class TsetUser(User):
	#设置等待时间间隔为2~15秒
	wait_time =  between(2,15)

⑦weight=10：选择用户的权重， 数值越高，被选中的机会就越大

3、HttpUser class

class HttpUser(*args, **kwargs)

官网原话：

1、Represents an HTTP “user” which is to be spawned and attack the system that is to be load tested.
2、The behaviour of this user is defined by its tasks. Tasks can be declared either directly on the class by using the @task decorator on methods, or by setting the tasks attribute.
3、This class creates a client attribute on instantiation which is an HTTP client with support for keeping a user session between requests.

翻译出来就是：

1、要进行负载测试的 HTTP 的user
2、该用户的行为由其任务定义。可以使用 @task装饰器或者设置 task属性直接在类上声明任务。
3、此类实例化时创建一个客户端属性，该属性是一个HTTP客户端，支持在请求之间保持用户会话。

3.2 类及用法

① abstract= True
若为True，则该类则被子类化，并且用户在测试期间，不会选择locust。

②client: locust.clients.HttpSession= None
在Locust实例化后创建Http Session实例。
并且这个客户端支持 cookie，可以保持HTTP请求之间的会话，直到结束，或者被强制停止。

4、TaskSet class

4.1 定义

class TaskSet(parent)

官网原话：

1、Class defining a set of tasks that a User will execute.
2、When a TaskSet starts running, it will pick a task from the tasks attribute, execute it, and then sleep for the number of seconds returned by its wait_time function. If no wait_time method has been declared on the TaskSet, it’ll call the wait_time function on the User by default. It will then schedule another task for execution and so on.
3、TaskSets can be nested, which means that a TaskSet’s tasks attribute can contain another TaskSet. If the nested TaskSet is scheduled to be executed, it will be instantiated and called from the currently executing TaskSet. Execution in the currently running TaskSet will then be handed over to the nested TaskSet which will continue to run until it throws an InterruptTaskSet exception, which is done when TaskSet.interrupt() is called. (execution will then continue in the first TaskSet).

翻译出来就是：

1、定义用户将要执行的一组任务的类。
2、TaskSet开始运行时，它将从task属性中选择一个任务，来执行，然后执行wait_time()函数；如果没有在TaskSet上声明任何wait_time方法，则默认情况将调用User.wait_time()函数。
3、TaskSet可以嵌套，这意味着TaskSet的task属性可以包含另一个TaskSet。
如果计划执行TaskSet，将从当前正在执行的TaskSet实例化并调用。然后，当前正在运行的TaskSet中的执行将移交给嵌套的 TaskSet，它将继续运行，直到抛出 异常，该异常在调用TaskSet.interrupt()时完成。

4.2 类及用法

① propertyclient：是TaskSet 的client的一个"快捷方式"

②on_start()：表示开始运行TaskSet

③on_stop()：表示停止运行TaskSet

④interrupt(reschedule=True)
默认为True，父级用户将立即重新安排并执行新任务。中断TaskSet并将任务移交给父TaskSet

⑤wait()：设置等待， 在函数 Locust.wait_time(或者TaskSet.wait_time函数)中定义
stop_timeout：禁止 任务中休眠
gevent.sleep()：休眠

⑥wait_time()：设置等待时间间隔，单位是 秒，可以对单个TaskSet 设置
例如：

from locust import TaskSet,between

class Task(TaskSet):
	#设置等待时间间隔为2~15秒
	wait_time =  between(2,15)

⑦property parent：此TaskSet 的父TaskSet实例。

⑧schedule_task(task_callable, first=False)：将任务添加到用户的任务执行队列。
task_callable：要计划的用户任务
first：可选参数，为True，则放在任务队列的首位

⑨tasks: List[Union[TaskSet, Callable]]= []：表示将要运行TaskSet类的集合
如果任务是列表，则随机选择要执行的任务；
如果任务是两个元组(可调用，整数)列表，或者是字典，则随机选择要执行的任务，但是会根据其相应的值来对每个任务进行加权。
例如：

class ForumPage(TaskSet):
	#设置权数值
    tasks = {
    	ThreadPage: 20, 
    	write_post: 1
    }
# 可以看出，被选中的 ThreadPage 的可能是 write_post 的20倍。

与User的task定义内容一致。

⑩property user：创建TaskSet 实例

5、task decorator

5.1 类及用法

①@task(weight=1)：用作便利修饰器，以便能够为类中的内联用户或TaskSet声明任务
例如：

class ForumPage(TaskSet):
	'''
	设置TaskSet 类
	定义两个函数，
	read_thread :task设置 100
	create_thread: task设置 7
	'''
	#设置权值
	@task(100)
    def read_thread(self):
    	pass
    
    @task(7)
    def create_thread(self):
    	pass

6、tag decorator

6.1 类及用法

①@tag(＊tags)：装饰器，用于使用给定的 tag 名进行标记任务 和 TaskSet
可以将测试限定仅执行使用–tag命令行参数提供的任何标签标记的任务
例如：

class ForumPage(TaskSet):
	#设置tag标签
	@tag('thread')
	#设置权重值
	@task(100)
    def read_thread(self):
    	pass
    
    @tag('thread')
    @tag('post')
    @task(7)
    def create_thread(self):
    	pass

    @tag('post')
    @task(22)
    def comment(self):
    	pass

7、Sequential TaskSet class

7.1 定义

class SequentialTaskSet(*args, **kwargs)

官网原话：

1、Class defining a sequence of tasks that a User will execute.
2、Works like TaskSet, but task weight is ignored, and all tasks are executed in order. Tasks can either be specified by setting the tasks attribute to a list of tasks, or by declaring tasks as methods using the @task decorator. The order of declaration decides the order of execution.
3、It’s possible to combine a task list in the tasks attribute, with some tasks declared using the @task decorator. The order of declaration is respected also in that case.

翻译出来就是：

1、定义用户将要执行的任务序列的类。
2、像TaskSet一样工作，但是忽略任务权重，按顺序执行所有任务。可以通过将task属性设置为任务列表来指定任务，也可以使用@task装饰器将任务声明为方法。声明的顺序决定执行的顺序。
3、可以将task属性中的任务列表与使用@task装饰器声明的某些任务合在一起。同时需要遵循声明的顺序。

7.2 类及用法

① propertyclient：是TaskSet 的client的一个"快捷方式"

②on_start()：表示开始运行TaskSet

③on_stop()：表示停止运行TaskSet

④interrupt(reschedule=True)
默认为True，父级用户将立即重新安排并执行新任务。中断TaskSet并将任务移交给父TaskSet

⑤property user：创建TaskSet 实例

⑥wait_time()：设置等待时间间隔，单位是 秒，可以对单个TaskSet 设置
例如：

from locust import TaskSet,between

class Task(TaskSet):
	#设置等待时间间隔为2~15秒
	wait_time =  between(2,15)

⑦property parent：此TaskSet 的父TaskSet实例

⑧schedule_task(task_callable, first=False)：将任务添加到用户的任务执行队列
task_callable：要计划的用户任务
first：可选参数，为True，则放在任务队列的首位

8、Built in wait_time functions

8.1 类及用法

①between(min_wait, max_wait)：返回一个函数，在min_wait 与 max_wait之间返回一个随机数
例如：

class TestUser(User):
	#每个任务等待3秒~15.9秒
	wait_time = between(3.0,15.9)

②constant(wait_time)：返回一个仅返回有wait_time参数指定的数字的函数
例如：

class TestUser(User):
	wait_time = constant(5)

③constant_pacing(wait_time)：返回一个函数，该函数将跟踪任务的运行时间，并且每次调用该函数时，它将返回一个等待时间，该等待时间将使任务执行之间的总时间等于wait_time参数指定的时间
例如：

class MyUser(User):
    wait_time = constant_pacing(1)
    @task
    def my_task(self):
        time.sleep(random.random())

解析：
1、无论任务执行时间如何，任务总是每秒执行一次；
2、如果任务执行超过指定的wait_time，则在开始下一个任务之前等待将为 0

①、《Locust性能自动化—初识性能测试》

带你认识性能测试，了解性能测试需要关注哪些指标。

②、《Locust性能自动化-Locust介绍》

带你认识 locust，从此不再仅限于 Loadrunner、Jmeter性能功能。

③、《Locust性能自动化—代码实战》

让你了解locust的内涵，自己也可以动手写性能测试脚本。

④、《Locust性能自动化—如何提高Locust性能》

让你提高性能，遨游性能的海洋。

⑤《Locust性能自动化—自定义客户端测试》

了解自定义客户端，可以轻松扩展对任何基于请求/响应的系统进行负载测试。

原文链接：https://www.cxybb.com/article/wuyoudeyuer/109049610