class Profiles(HttpUser):
wait_time = constant(2)
@tag('profiles')
@task()
def get_profiles(self):
self.client.get("/api/profiles",
headers={
'Authorization':
'Token ' +
'8ca72bac81117043cef2aafa3b0ea34e02369971'
})
@tag('profiles')
@task()
def get_profile_detail(self):
for item_id in range(3070, 3080):
self.client.get("/api/profiles/" + str(item_id),
headers={
'Authorization':
'Token ' +
'8ca72bac81117043cef2aafa3b0ea34e02369971'
})
def on_start(self):
self.client.post("/api/login",
json={
"username": "******",
"password": "******"
})
class MyHybridUser(User):
wait_time = constant(1)
widget_count = 0
def on_start(self):
self.widget_maker = WidgetMaker()
return super().on_start()
@task
def my_task(self):
start_at = time.time()
widget = self.widget_maker.get_widget()
#pass if the widget is “good”, otherwise fail
if widget == "good":
self.environment.events.request_success.fire(
request_type="WidgetMaker",
name="make_widget",
response_time=(time.time() - start_at) * 1000,
response_length=len(widget))
else:
self.environment.events.request_failure.fire(
request_type="WidgetMaker",
name="make_widget",
response_time=(time.time() - start_at) * 1000,
response_length=len(widget),
exception=widget)
class CpuUser(User):
wait_time = constant(0.001)
@task
def cpu_task(self):
for i in range(1000000):
_ = 3 / 2
class MyUser(User):
host = "http://example.com"
wait_time = constant(1)
@task(1)
def my_task(self):
my_dict["val"] = self.environment.parsed_options.my_argument
class User(Locust):
wait_time = constant(1)
task_run_count = 0
@task
def my_task(self):
User.task_run_count += 1
class cacheService(HttpUser):
wait_time = constant(1)
ids = []
@task
def create(self):
id = uuid.uuid4()
payload = {"username": str(id)}
headers = {'content-type': 'application/json'}
resp = self.client.post("/cache/new",
data=json.dumps(payload),
headers=headers)
if resp.status_code == 200:
out = resp.json()
cache_id = out["_id"]
self.ids.append(cache_id)
@task
def get(self):
if len(self.ids) == 0:
self.create()
else:
rid = random.choice(self.ids)
self.client.get(f"/cache/{rid}")
class User(HttpUser):
wait_time = constant(1)
@task
def get_breeds_by_id(self):
self.client.get(
"/breeds/9C468727-01AC-462D-9392-404CAEC2282E?useIndex=true&useCache=true&devNull=true"
)
@task
def get_breeds_by_popularity(self):
self.client.get(
"/breeds?popularity=125&useIndex=true&useCache=true&devNull=true")
@task
def get_breeds_by_group_and_dog(self):
self.client.get(
"/breeds?group=Working&dog=Baxter&useIndex=true&useCache=true&devNull=true"
)
@task
def get_breeds_by_groupId(self):
self.client.get(
"/breeds?groupId=C6860975-68A0-46D3-8B32-F297BA14B070&useIndex=true&useCache=true&devNull=true"
)
class TagUser(HttpUser):
"""
@tag 装饰器，标记模拟用户的任务，可以通过 `--tags` 和 `--exclude-tags` 来指定那些任务执行和不被执行
$ locust -f ....py --tags tag1 --exclude-tags tag3
"""
wait_time = constant(1)
@tag('tag1')
@task
def task1(self):
pass
@tag('tag1', 'tag2')
@task
def task2(self):
pass
@tag('tag3')
@task
def task3(self):
pass
@task
def task4(self):
pass
class TirtonLocust(User):
host = 'http://127.0.0.1:8000'
wait_time = constant(0.1)
model_name = "molbart"
@task
@stopwatch('Triton_Sample')
def client_task(self):
with httpclient.InferenceServerClient('localhost:8000') as client:
input0_data = np.array(['CN1C=NC2=C1C(=O)N(C(=O)N2C)C'
]).astype(np.object)
inputs = [
httpclient.InferInput("INPUT0", input0_data.shape,
np_to_triton_dtype(input0_data.dtype)),
]
inputs[0].set_data_from_numpy(input0_data)
outputs = [
httpclient.InferRequestedOutput("OUTPUT0"),
]
response = client.infer(TirtonLocust.model_name,
inputs,
request_id=str(1),
outputs=outputs)
result = response.get_response()
class LoggedInUser(User):
wait_time = constant(5)
tasks = {ForumSection: 2}
@task
def my_task(self):
pass
class MyReqRes(HttpUser):
wait_time = constant(1)
host = "https://flask-ml-azure.azurewebsites.net/"
@task
def get_users(self):
res = self.client.get("/")
print(res.status_code)
assert res.status_code == 200
@task
def predict(self):
data = {
"CHAS": {
"0": 0
},
"RM": {
"0": 6.575
},
"TAX": {
"0": 296.0
},
"PTRATIO": {
"0": 15.3
},
"B": {
"0": 396.9
},
"LSTAT": {
"0": 4.98
}
}
response = self.client.post('/predict', json=data)
assert response.status_code == 200
class MySubTaskSet(TaskSet):
constant(1)
@task()
def a_task(self):
self.locust.sub_locust_task_executed = True
self.interrupt()
class UserBehavior(SequentialTaskSet):
wait_time = constant(1)
@task
def login(self):
number = random.randint(1, 500000)
name = f'dummy_{number}'
self.client.post('/login', {
'name': name,
'password': name
},
None,
name="login")
@task
def profile(self):
self.client.get('/user', name="show_user")
tasks = [ArticleTaskSet]
@task
def logout(self):
self.client.post('/logout', None, None, name="logout")
self.interrupt(False)
class MyLoadTest(HttpUser):
wait_time = constant(1)
@task
def launch(self):
self.client.get("/")
class PasswordGenUser(HttpUser):
wait_time = constant(1)
@task(2)
def long_passwords(self):
self.client.get("http://password-gen-api:8080/api/password?length=64")
@task(4)
def average_passwords(self):
self.client.get("http://password-gen-api:8080/api/password?length=16")
@task(2)
def short_passwords(self):
self.client.get("http://password-gen-api:8080/api/password?length=8")
@task(2)
def default_passwords(self):
self.client.get("http://password-gen-api:8080/api/password")
@task(1)
def validation_error(self):
with self.client.get(
"http://password-gen-api:8080/api/password?length=128",
catch_response=True) as response:
if response.status_code == 400:
response.success()
class User(HttpUser):
wait_time = constant(1)
host = base
@task
def my_task(self):
self.client.get(path)
class MyUser2(User):
wait_time = constant(0)
weight = 0
@task
def my_task(self):
pass
class WebdriverExample(User):
wait_time = constant(0.25)
host = "https://staging.propcert.co.uk/my-admin"
def __init__(self, environment):
#chrome_options = Options()
#chrome_options.add_argument("--disable-extensions")
#chrome_options.add_argument("--disable-gpu")
#chrome_options.add_argument("--headless")
#super().__init__(environment)
#self.driver = webdriver.Chrome("C:\chromedriver", options=chrome_options)
self.driver = webdriver.Chrome("C:\chromedriver")
def on_stop(self):
self.driver.close()
@task
def home(self):
start_at = time.time()
self.driver.get(self.host)
elem = self.driver.find_element_by_name("username")
elem.clear()
elem.send_keys("faisal")
elem = self.driver.find_element_by_name("password")
elem.clear()
elem.send_keys("Dlogic123!")
elem.send_keys(Keys.RETURN)
class RedisLocust(User):
wait_time = constant(0.1)
key_range = 500
def __init__(self, *args, **kwargs):
super(RedisLocust, self).__init__(*args, **kwargs)
self.client = RedisClient()
self.key = 'key1'
self.value = 'value1'
@task(2)
def get_time(self):
for i in range(self.key_range):
self.key = 'key' + str(i)
self.client.query(self.key)
@task(1)
def write(self):
for i in range(self.key_range):
self.key = 'key' + str(i)
self.value = 'value' + str(i)
self.client.write(self.key, self.value)
@task(1)
def get_key(self):
var = str(randint(1, self.key_range - 1))
self.key = 'key' + var
self.value = 'value' + var
class BaseUser(User):
wait_time = constant(1)
@task
class task_set(TaskSet):
@task
def trigger(self):
triggered[0] = True
class User(HttpUser):
wait_time = constant(1)
@task
def get_owners_by_id(self):
self.client.get(
"/owners/8F5983DE-48B8-4557-873D-0002AC1A0131?useIndex=false&useCache=true&devNull=true"
)
@task
def get_owners_by_name(self):
self.client.get(
"/owners?firstName=Yoselin&lastName=Gilmore&useIndex=false&useCache=true&devNull=true"
)
@task
def get_owners_by_country(self):
self.client.get(
"/owners?countryCode=CA&useIndex=false&useCache=true&devNull=true")
@task
def get_owners_by_dogId(self):
self.client.get(
"/owners?dogId=8ABF7EEB-EFFC-473F-912A-1293BDEC74A4&useIndex=false&useCache=true&devNull=true"
)
@task
def get_owners_by_dog_breed_and_name(self):
self.client.get(
"/owners?breed=Greyhound&dog=Sandy&useIndex=false&useCache=true&devNull=true"
)
class MyLocust(Locust):
wait_time = constant(1)
class task_set(TaskSet):
@task(1)
def my_task(self):
pass
class CpuLocust(Locust):
wait_time = constant(0.001)
@task
def cpu_task(self):
for i in range(1000000):
_ = 3 / 2
class User(HttpUser):
wait_time = constant(1)
@task
def get_dogs_by_id(self):
self.client.get(
"/dogs/64F67DAB-5E32-4A7F-9655-0000210A4708?useIndex=false&useCache=false&devNull=true"
)
@task
def get_dogs_by_group_and_code(self):
self.client.get(
"/dogs?group=Sporting&countryCode=CA&useIndex=false&useCache=false&devNull=true"
)
@task
def get_dogs_by_name_and_breed(self):
self.client.get(
"/dogs?name=Tucker&breed=Labrador Retriever&useIndex=false&useCache=false&devNull=true"
)
@task
def get_dogs_by_owner_name(self):
self.client.get(
"/dogs?ownerFirstName=Dax&ownerLastName=Christian&useIndex=false&useCache=false&devNull=true"
)
class MySubTaskSet(TaskSet):
wait_time = constant(0.001)
@task()
def a_task(self):
self.user.sub_locust_task_executed = True
self.interrupt()
class TemperatureSensor(FastHttpUser):
wait_time = constant(1)
# instance of task can represent one type. (One device may send various data)
@task
def post_input(self):
# retrieve the dev instance
dev_id = Util.get_id(self, "dev")
if dev_id in device_instance:
dev = device_instance[dev_id]
else:
dev = Util.get_cyclic_random_sensor_data(init_elapsed_time=0,
period=300,
min=-10,
max=45,
error_rate=0.1)
device_instance[dev_id] = dev
json_data = {
"id": Util.get_id(self, "dev"),
"value": dev.next_value(),
"seq": dev.get_message_seq(),
"time": Util.get_current_time()
}
response = self.client.post(
path="/api/v1/resources/topics//locust/scenario/2",
data=Util.get_json_with_size(json_data, 1000),
auth=None,
headers={
"Authorization": "Bearer {}".format(Util.get_access_token()),
"Content-Type": "application/json"
},
name=Util.get_class_name(self))
class reportService(HttpUser):
wait_time = constant(1)
def _do_async_thing_handler(self, timeout=600):
post_resp = requests.post(self.host + 'report')
if not post_resp.status_code == 200:
return
id = post_resp.json()['report_id']
print(id)
# Now poll for an ACTIVE status
start_time = time.monotonic()
end_time = start_time + timeout
while time.monotonic() < end_time:
r = requests.get(self.host + 'report/' + id)
if r.status_code == 200 and r.json()['result'] != None:
async_success('POST /report/ID - async', start_time, post_resp)
return
# IMPORTANT: Sleep must be monkey-patched by gevent (typical), or else
# use gevent.sleep to avoid blocking the world.
time.sleep(1)
async_failure('POST /report/ID - async', start_time, post_resp,
'Failed - timed out after %s seconds' % timeout)
@task
def do_async_thing(self):
gevent.spawn(self._do_async_thing_handler)
class RedisLocust(Locust):
def __init__(self, *args, **kwargs):
self.client = RedisClient()
super(RedisLocust, self).__init__(*args, **kwargs)
wait_time = constant(0)
task_set = User
class MyUser(User):
wait_time = constant(1)
task_run_count = 0
@task
def my_task(self):
MyUser.task_run_count += 1
class StableCoinUser(User):
wait_time = constant(0)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# client
self.node_session = HttpSession(
base_url="http://128.199.13.131:9000",
request_success=self.environment.events.request_success,
request_failure=self.environment.events.request_failure,
)
# platform
self.platform_session = HttpSession(
base_url="http://128.199.14.196:80",
request_success=self.environment.events.request_success,
request_failure=self.environment.events.request_failure,
)
@task
def transfer(self):
# 1) prepare (and sign) HSC transfer transaction
hsc_transaction, operator, valid_start = prepare_hsc_transfer_transaction(
)
# 2) sign Hedera (HCS) transaction
response = self.platform_session.post("/hedera/transaction",
data=hsc_transaction)
# 3) submit Hedera (HCS) transaction (x1000)
send_hedera_transaction(response.content)
# 4) wait for confirmation
wait_for_confirmation(self.node_session, operator, valid_start)
