import logging
import os
import random
import re
import uuid
from locust import HttpUser, task, between, events
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger = logging.getLogger("locust")
SEED_USERS = []
ALL_USERNAMES = []
USER_UIDS = []
POST_UIDS = []
POST_SLUGS = []
PROJECT_UIDS = []
PROJECT_SLUGS = []
COMMENT_UIDS = []
NEWS_UIDS = []
NEWS_SLUGS = []
GIST_SLUGS = []
GIST_UIDS = []
NOTIFICATION_UIDS = []
ADMIN_USER = {}
ADMIN_TARGETS = {}
TOPICS = ["devlog", "showcase", "question", "rant", "fun", "random"]
PROJECT_TYPES = ["game", "game_asset", "software", "mobile_app", "website"]
GIST_LANGUAGES = ["python", "javascript", "go", "rust", "bash", "sql", "json"]
UPLOAD_FILE = ("load_test.txt", b"locust upload payload", "text/plain")
AVATAR_STYLES = [
"adventurer", "adventurer-neutral", "avataaars", "bottts", "identicon",
"initials", "lorelei", "micah", "open-peeps", "pixel-art", "shapes",
]
UUID_RE = r'[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'
PASSWORD = "testpass123"
def random_username():
return f"lu_{uuid.uuid4().hex[:10]}"
def do_signup(client, username, email):
with client.post("/auth/signup", data={
"username": username, "email": email,
"password": PASSWORD, "confirm_password": PASSWORD,
}, catch_response=True, name="signup") as resp:
if resp.status_code == 200 and resp.history:
resp.success()
return True
resp.failure(f"signup failed: status={resp.status_code}")
return False
def do_login(client, email):
with client.post("/auth/login", data={
"email": email, "password": PASSWORD,
}, catch_response=True, name="login") as resp:
if resp.status_code == 200 and resp.history:
resp.success()
return True
resp.failure(f"login failed: status={resp.status_code}")
return False
@events.init.add_listener
def seed_data(environment, **kwargs):
host = environment.host or "http://127.0.0.1:10502"
logger.info(f"Seeding {host}...")
import urllib.request
import urllib.parse
import http.cookiejar
created = 0
while created < 5:
username = random_username()
email = f"{username}@locust.devplace"
body = urllib.parse.urlencode({
"username": username, "email": email,
"password": PASSWORD, "confirm_password": PASSWORD,
}).encode()
req = urllib.request.Request(f"{host}/auth/signup", data=body)
try:
urllib.request.urlopen(req, timeout=10)
SEED_USERS.append({"username": username, "email": email})
ALL_USERNAMES.append(username)
created += 1
except Exception as e:
logger.warning(f"Create seed user failed: {e}")
logger.info(f"Created {len(SEED_USERS)} seed users")
def logged_in_opener(email):
jar = http.cookiejar.CookieJar()
opener = urllib.request.build_opener(
urllib.request.HTTPCookieProcessor(jar)
)
body = urllib.parse.urlencode({"email": email, "password": PASSWORD}).encode()
opener.open(
urllib.request.Request(f"{host}/auth/login", data=body), timeout=10
)
return opener
for seed in SEED_USERS[:3]:
try:
opener = logged_in_opener(seed["email"])
body = urllib.parse.urlencode({
"content": "x " * 100,
"title": f"Seed post {uuid.uuid4().hex[:6]}",
"topic": random.choice(TOPICS),
}).encode()
resp = opener.open(
urllib.request.Request(f"{host}/posts/create", data=body),
timeout=10,
)
m = re.search(r"/posts/(\S+)", resp.url)
if m and m.group(1) not in POST_SLUGS:
POST_SLUGS.append(m.group(1))
html = resp.read().decode("utf-8", errors="replace")
m2 = re.search(rf'/votes/post/({UUID_RE})', html)
if m2 and m2.group(1) not in POST_UIDS:
POST_UIDS.append(m2.group(1))
except Exception as e:
logger.warning(f"Create seed post failed: {e}")
logger.info(f"Created {len(POST_UIDS)} seed posts")
for seed in SEED_USERS[:2]:
try:
opener = logged_in_opener(seed["email"])
body = urllib.parse.urlencode({
"content": f"Seed comment by {seed['username']}",
"post_uid": POST_UIDS[0],
}).encode()
opener.open(
urllib.request.Request(f"{host}/comments/create", data=body),
timeout=10,
)
except Exception as e:
logger.warning(f"Create seed comment failed: {e}")
for seed in SEED_USERS[:2]:
try:
opener = logged_in_opener(seed["email"])
body = urllib.parse.urlencode({
"title": f"Project {uuid.uuid4().hex[:6]}",
"description": "z " * 50,
"project_type": random.choice(PROJECT_TYPES),
}).encode()
opener.open(
urllib.request.Request(f"{host}/projects/create", data=body),
timeout=10,
)
except Exception as e:
logger.warning(f"Create seed project failed: {e}")
for seed in SEED_USERS[:2]:
try:
opener = logged_in_opener(seed["email"])
body = urllib.parse.urlencode({
"title": f"Gist {uuid.uuid4().hex[:6]}",
"description": "Seed gist for load testing.",
"source_code": "print('hello')\n" * 5,
"language": random.choice(GIST_LANGUAGES),
}).encode()
resp = opener.open(
urllib.request.Request(f"{host}/gists/create", data=body),
timeout=10,
)
m = re.search(r"/gists/(\S+)", resp.url)
if m and m.group(1) not in GIST_SLUGS:
GIST_SLUGS.append(m.group(1))
html = resp.read().decode("utf-8", errors="replace")
m2 = re.search(rf'/votes/gist/({UUID_RE})', html)
if m2 and m2.group(1) not in GIST_UIDS:
GIST_UIDS.append(m2.group(1))
except Exception as e:
logger.warning(f"Create seed gist failed: {e}")
logger.info(f"Created {len(GIST_SLUGS)} seed gists")
# ── Seed news articles (direct DB insert) ───────────────────
try:
from devplacepy.database import get_table, init_db
from devplacepy.utils import make_combined_slug
init_db()
news_table = get_table("news")
for i in range(3):
title = f"Locust news article {i} {uuid.uuid4().hex[:4]}"
article_uid = str(uuid.uuid4())
slug = make_combined_slug(title, article_uid)
news_table.insert({
"uid": article_uid, "slug": slug, "title": title,
"external_id": f"locust_seed_{i}", "grade": 8,
"status": "published", "show_on_landing": 1,
"source_name": "Locust", "synced_at": "2026-01-01T00:00:00",
"description": "Locust seed article for load testing.",
})
NEWS_UIDS.append(article_uid)
NEWS_SLUGS.append(slug)
admin_news_uid = str(uuid.uuid4())
admin_news_title = f"Admin target news {uuid.uuid4().hex[:4]}"
news_table.insert({
"uid": admin_news_uid,
"slug": make_combined_slug(admin_news_title, admin_news_uid),
"title": admin_news_title,
"external_id": f"locust_admin_target_{uuid.uuid4().hex[:6]}",
"grade": 5, "status": "published", "show_on_landing": 0,
"source_name": "Locust", "synced_at": "2026-01-01T00:00:00",
"description": "Dedicated target for admin news mutations.",
})
ADMIN_TARGETS["news_uid"] = admin_news_uid
except Exception as e:
logger.warning(f"Seed news articles failed: {e}")
# ── Seed an admin user (direct DB insert) ───────────────────
try:
from datetime import datetime, timezone
from devplacepy.database import get_table, init_db
from devplacepy.utils import hash_password, generate_uid
init_db()
username = f"lu_admin_{uuid.uuid4().hex[:6]}"
email = f"{username}@locust.devplace"
get_table("users").insert({
"uid": generate_uid(),
"username": username,
"email": email,
"password_hash": hash_password(PASSWORD),
"bio": "", "location": "", "git_link": "", "website": "",
"role": "Admin", "is_active": True,
"level": 1, "xp": 0, "stars": 0,
"created_at": datetime.now(timezone.utc).isoformat(),
})
ADMIN_USER["username"] = username
ADMIN_USER["email"] = email
ALL_USERNAMES.append(username)
disposable_uid = generate_uid()
disposable_name = f"lu_target_{uuid.uuid4().hex[:6]}"
get_table("users").insert({
"uid": disposable_uid,
"username": disposable_name,
"email": f"{disposable_name}@locust.devplace",
"password_hash": hash_password(PASSWORD),
"bio": "", "location": "", "git_link": "", "website": "",
"role": "Member", "is_active": True,
"level": 1, "xp": 0, "stars": 0,
"created_at": datetime.now(timezone.utc).isoformat(),
})
ADMIN_TARGETS["disposable_uid"] = disposable_uid
logger.info(f"Created admin user {username} and disposable target")
except Exception as e:
logger.warning(f"Seed admin user failed: {e}")
# ── Harvest UIDs from HTML responses ──────────────────────
# projects sidebar: /projects?user_uid={uuid}
# project cards: /votes/project/{uuid}
# comment deletion: /comments/delete/{uuid}
uuid_pat = rf'({UUID_RE})'
for seed in SEED_USERS:
try:
opener = logged_in_opener(seed["email"])
resp = opener.open(
urllib.request.Request(f"{host}/projects"), timeout=10
)
html = resp.read().decode("utf-8", errors="replace")
m = re.search(rf'/projects\?user_uid={uuid_pat}', html)
if m and m.group(1) not in USER_UIDS:
USER_UIDS.append(m.group(1))
proj_matches = re.findall(rf'/votes/project/{uuid_pat}', html)
PROJECT_UIDS.extend(
p for p in proj_matches if p not in PROJECT_UIDS
)
slug_matches = re.findall(r'href="/projects/([^"/?#]+)"', html)
PROJECT_SLUGS.extend(
s for s in slug_matches
if s not in PROJECT_SLUGS and s not in ("create",)
)
except Exception as e:
logger.warning(f"Harvest from {seed['username']} failed: {e}")
if POST_UIDS:
try:
opener = logged_in_opener(SEED_USERS[0]["email"])
resp = opener.open(
urllib.request.Request(f"{host}/posts/{POST_UIDS[0]}"),
timeout=10,
)
html = resp.read().decode("utf-8", errors="replace")
matches = re.findall(rf'/comments/delete/{uuid_pat}', html)
COMMENT_UIDS.extend(m for m in matches if m not in COMMENT_UIDS)
except Exception as e:
logger.warning(f"Harvest comment UIDs failed: {e}")
logger.info(
f"Seed complete: {len(SEED_USERS)} users, {len(POST_UIDS)} posts, "
f"{len(PROJECT_UIDS)} projects ({len(PROJECT_SLUGS)} slugs), "
f"{len(GIST_UIDS)} gists, {len(COMMENT_UIDS)} comments, "
f"{len(USER_UIDS)} uids"
)
class DevPlaceUser(HttpUser):
weight = 20
wait_time = between(1, 5)
def on_start(self):
self.own_post_slugs = []
self.own_gist_slugs = []
self.own_project_slugs = []
if random.random() < 0.3 and SEED_USERS:
seed = random.choice(SEED_USERS)
do_login(self.client, seed["email"])
self.username = seed["username"]
else:
username = random_username()
email = f"{username}@locust.devplace"
do_signup(self.client, username, email)
self.username = username
ALL_USERNAMES.append(username)
# ── browsing ────────────────────────────────────────────────
@task(5)
def view_feed(self):
tab = random.choice(["all", "trending", "recent", "following"])
topic = random.choice([None] + TOPICS)
params = {"tab": tab}
if topic:
params["topic"] = topic
self.client.get("/feed", params=params, name="feed")
@task(4)
def view_post(self):
slugs = POST_SLUGS if POST_SLUGS else POST_UIDS
if not slugs:
return
self.client.get(
f"/posts/{random.choice(slugs)}", name="posts/[uid]"
)
@task(3)
def view_profile(self):
if not ALL_USERNAMES:
return
self.client.get(
f"/profile/{random.choice(ALL_USERNAMES)}", name="profile/[username]"
)
@task(3)
def view_projects(self):
self.client.get("/projects", params={
"tab": random.choice(["recent", "released", "popular", "new"]),
}, name="projects")
@task(1)
def view_landing(self):
self.client.get("/", name="landing")
@task(1)
def view_auth_forms(self):
self.client.get(
random.choice(["/auth/signup", "/auth/login"]), name="auth/form"
)
@task(3)
def view_news(self):
self.client.get("/news", name="news")
@task(2)
def view_news_detail(self):
slugs = NEWS_SLUGS if NEWS_SLUGS else NEWS_UIDS
if not slugs:
return
self.client.get(
f"/news/{random.choice(slugs)}", name="news/[slug]"
)
@task(1)
def view_bugs(self):
self.client.get("/bugs", name="bugs")
@task(3)
def view_project_detail(self):
if not PROJECT_SLUGS:
return
self.client.get(
f"/projects/{random.choice(PROJECT_SLUGS)}", name="projects/[slug]"
)
@task(2)
def view_gists(self):
self.client.get("/gists", name="gists")
@task(2)
def view_gist_detail(self):
if not GIST_SLUGS:
return
self.client.get(
f"/gists/{random.choice(GIST_SLUGS)}", name="gists/[slug]"
)
@task(1)
def search_profiles(self):
term = random.choice(ALL_USERNAMES)[:5] if ALL_USERNAMES else "lu"
self.client.get(
"/profile/search", params={"q": term}, name="profile/search"
)
@task(1)
def search_messages(self):
term = random.choice(ALL_USERNAMES)[:5] if ALL_USERNAMES else "lu"
self.client.get(
"/messages/search", params={"q": term}, name="messages/search"
)
@task(1)
def view_seo(self):
self.client.get(
random.choice(["/robots.txt", "/sitemap.xml"]), name="seo"
)
@task(1)
def view_static(self):
self.client.get("/static/css/base.css", name="static")
# ── auth flows ──────────────────────────────────────────────
@task(1)
def login_flow(self):
if not SEED_USERS:
return
do_login(self.client, random.choice(SEED_USERS)["email"])
@task(1)
def logout_and_relogin(self):
self.client.get("/auth/logout", name="auth/logout")
self.client.get("/", name="landing")
if SEED_USERS:
do_login(self.client, random.choice(SEED_USERS)["email"])
@task(1)
def view_forgot_password(self):
self.client.get("/auth/forgot-password", name="auth/forgot-password")
@task(1)
def request_password_reset(self):
email = random.choice(SEED_USERS)["email"] if SEED_USERS else "x@locust.devplace"
self.client.post(
"/auth/forgot-password", data={"email": email},
name="auth/forgot-password/post",
)
@task(1)
def reset_password_flow(self):
token = uuid.uuid4().hex + uuid.uuid4().hex
self.client.get(
f"/auth/reset-password/{token}", name="auth/reset-password"
)
self.client.post(
f"/auth/reset-password/{token}",
data={"password": PASSWORD, "confirm_password": PASSWORD},
name="auth/reset-password/post",
)
# ── content creation ────────────────────────────────────────
@task(2)
def create_post(self):
data = {
"content": "x " * 100,
"title": f"Load test {uuid.uuid4().hex[:6]}",
"topic": random.choice(TOPICS),
}
with self.client.post("/posts/create", data=data,
catch_response=True,
name="posts/create") as resp:
if resp.status_code == 200 and resp.history:
m = re.search(r"/posts/(\S+)", resp.url)
if m:
slug = m.group(1)
if slug not in POST_SLUGS:
POST_SLUGS.append(slug)
self.own_post_slugs.append(slug)
m2 = re.search(rf'/votes/post/({UUID_RE})', resp.text)
if m2 and m2.group(1) not in POST_UIDS:
POST_UIDS.append(m2.group(1))
resp.success()
else:
resp.failure("post not created")
@task(2)
def comment_on_post(self):
if not POST_UIDS:
return
self.client.post("/comments/create", data={
"content": f"Comment {uuid.uuid4().hex[:6]} " * 3,
"post_uid": random.choice(POST_UIDS),
}, name="comments/create")
@task(1)
def create_project(self):
with self.client.post("/projects/create", data={
"title": f"Project {uuid.uuid4().hex[:6]}",
"description": "y " * 50,
"project_type": random.choice(PROJECT_TYPES),
}, catch_response=True, name="projects/create") as resp:
m = re.search(r"/projects/(\S+)", resp.url)
if resp.status_code == 200 and m:
slug = m.group(1)
if slug not in PROJECT_SLUGS:
PROJECT_SLUGS.append(slug)
self.own_project_slugs.append(slug)
resp.success()
else:
resp.failure("project not created")
@task(1)
def create_gist(self):
with self.client.post("/gists/create", data={
"title": f"Gist {uuid.uuid4().hex[:6]}",
"description": "Load test gist.",
"source_code": "x = 1\n" * 20,
"language": random.choice(GIST_LANGUAGES),
}, catch_response=True, name="gists/create") as resp:
m = re.search(r"/gists/(\S+)", resp.url)
if resp.status_code == 200 and m:
slug = m.group(1)
if slug not in GIST_SLUGS:
GIST_SLUGS.append(slug)
self.own_gist_slugs.append(slug)
m2 = re.search(rf'/votes/gist/({UUID_RE})', resp.text)
if m2 and m2.group(1) not in GIST_UIDS:
GIST_UIDS.append(m2.group(1))
resp.success()
else:
resp.failure("gist not created")
@task(1)
def create_bug(self):
self.client.post("/bugs/create", data={
"title": f"Bug {uuid.uuid4().hex[:6]}",
"description": "Load test bug report description.",
}, name="bugs/create")
# ── social interaction ──────────────────────────────────────
@task(2)
def vote_on_post(self):
if not POST_UIDS:
return
self.client.post(
f"/votes/post/{random.choice(POST_UIDS)}",
data={"value": random.choice([1, -1])},
name="votes/post",
)
@task(1)
def vote_on_project(self):
if not PROJECT_UIDS:
return
self.client.post(
f"/votes/project/{random.choice(PROJECT_UIDS)}",
data={"value": random.choice([1, -1])},
name="votes/project",
)
@task(1)
def vote_on_comment(self):
if not COMMENT_UIDS:
return
self.client.post(
f"/votes/comment/{random.choice(COMMENT_UIDS)}",
data={"value": random.choice([1, -1])},
name="votes/comment",
)
@task(1)
def vote_on_gist(self):
if not GIST_UIDS:
return
self.client.post(
f"/votes/gist/{random.choice(GIST_UIDS)}",
data={"value": random.choice([1, -1])},
name="votes/gist",
)
@task(1)
def follow_user(self):
targets = [u for u in ALL_USERNAMES if u != self.username]
if not targets:
return
self.client.post(
f"/follow/{random.choice(targets)}", name="follow/[username]"
)
@task(1)
def unfollow_user(self):
targets = [u for u in ALL_USERNAMES if u != self.username]
if not targets:
return
self.client.post(
f"/follow/unfollow/{random.choice(targets)}", name="follow/unfollow"
)
@task(1)
def send_message(self):
if not USER_UIDS or not SEED_USERS:
return
target_uid = random.choice(USER_UIDS)
self.client.post("/messages/send", data={
"content": f"Msg from {self.username}",
"receiver_uid": target_uid,
}, name="messages/send")
# ── user self-management ────────────────────────────────────
@task(1)
def update_profile(self):
self.client.post("/profile/update", data={
"bio": f"Updated at {uuid.uuid4().hex[:6]}",
"location": random.choice(["NL", "US", "DE", "UK", " "]),
}, name="profile/update")
@task(1)
def view_messages(self):
self.client.get("/messages", name="messages")
@task(1)
def view_notifications(self):
resp = self.client.get("/notifications", name="notifications")
matches = re.findall(rf'/notifications/mark-read/({UUID_RE})', resp.text)
NOTIFICATION_UIDS.extend(
m for m in matches if m not in NOTIFICATION_UIDS
)
@task(1)
def mark_all_notifications_read(self):
self.client.post("/notifications/mark-all-read", name="notifications/mark-all-read")
@task(1)
def mark_one_notification_read(self):
if not NOTIFICATION_UIDS:
return
self.client.post(
f"/notifications/mark-read/{random.choice(NOTIFICATION_UIDS)}",
name="notifications/mark-read",
)
@task(1)
def delete_comment(self):
if not COMMENT_UIDS:
return
self.client.post(
f"/comments/delete/{random.choice(COMMENT_UIDS)}",
name="comments/delete",
)
# ── owner-scoped mutations ──────────────────────────────────
@task(1)
def edit_post(self):
if not self.own_post_slugs:
return
self.client.post(
f"/posts/edit/{random.choice(self.own_post_slugs)}",
data={
"content": f"Edited {uuid.uuid4().hex} " * 3,
"title": "Edited post",
"topic": random.choice(TOPICS),
},
name="posts/edit",
)
@task(1)
def delete_post(self):
if not self.own_post_slugs:
return
slug = self.own_post_slugs.pop()
if slug in POST_SLUGS:
POST_SLUGS.remove(slug)
self.client.post(f"/posts/delete/{slug}", name="posts/delete")
@task(1)
def edit_gist(self):
if not self.own_gist_slugs:
return
self.client.post(
f"/gists/edit/{random.choice(self.own_gist_slugs)}",
data={
"title": "Edited gist",
"description": "Edited description.",
"source_code": "y = 2\n" * 20,
"language": random.choice(GIST_LANGUAGES),
},
name="gists/edit",
)
@task(1)
def delete_gist(self):
if not self.own_gist_slugs:
return
slug = self.own_gist_slugs.pop()
if slug in GIST_SLUGS:
GIST_SLUGS.remove(slug)
self.client.post(f"/gists/delete/{slug}", name="gists/delete")
@task(1)
def delete_project(self):
if not self.own_project_slugs:
return
slug = self.own_project_slugs.pop()
if slug in PROJECT_SLUGS:
PROJECT_SLUGS.remove(slug)
self.client.post(f"/projects/delete/{slug}", name="projects/delete")
@task(1)
def upload_file(self):
name, content, mime = UPLOAD_FILE
with self.client.post(
"/uploads/upload",
files={"file": (name, content, mime)},
catch_response=True, name="uploads/upload",
) as resp:
if resp.status_code == 201:
resp.success()
try:
uid = resp.json().get("uid")
except ValueError:
uid = None
if uid:
self.client.delete(
f"/uploads/delete/{uid}", name="uploads/delete"
)
else:
resp.failure(f"upload failed: status={resp.status_code}")
# ── static / media ──────────────────────────────────────────
@task(2)
def view_multiavatar(self):
seed = random.choice(ALL_USERNAMES) if ALL_USERNAMES else "anon"
self.client.get(
f"/avatar/multiavatar/{seed}?size=32", name="avatar/multiavatar"
)
@task(1)
def comment_on_news(self):
if not NEWS_UIDS:
return
self.client.post("/comments/create", data={
"content": f"News comment {uuid.uuid4().hex[:6]} " * 2,
"target_uid": random.choice(NEWS_UIDS),
"target_type": "news",
}, name="comments/news")
class AdminUser(HttpUser):
weight = 1
wait_time = between(2, 6)
def on_start(self):
if ADMIN_USER:
do_login(self.client, ADMIN_USER["email"])
@task(2)
def view_admin_index(self):
self.client.get("/admin", name="admin")
@task(3)
def view_admin_users(self):
self.client.get("/admin/users", name="admin/users")
@task(2)
def view_admin_settings(self):
self.client.get("/admin/settings", name="admin/settings")
@task(2)
def view_admin_news(self):
self.client.get("/admin/news", name="admin/news")
@task(2)
def view_admin_services(self):
self.client.get("/admin/services", name="admin/services")
@task(2)
def view_admin_services_data(self):
self.client.get("/admin/services/data", name="admin/services/data")
@task(1)
def save_settings(self):
self.client.post("/admin/settings", data={
"max_upload_size_mb": "10",
}, name="admin/settings/save")
@task(1)
def news_toggle(self):
uid = ADMIN_TARGETS.get("news_uid")
if not uid:
return
self.client.post(f"/admin/news/{uid}/toggle", name="admin/news/toggle")
@task(1)
def news_publish(self):
uid = ADMIN_TARGETS.get("news_uid")
if not uid:
return
self.client.post(f"/admin/news/{uid}/publish", name="admin/news/publish")
@task(1)
def news_landing(self):
uid = ADMIN_TARGETS.get("news_uid")
if not uid:
return
self.client.post(f"/admin/news/{uid}/landing", name="admin/news/landing")
@task(1)
def news_delete(self):
uid = ADMIN_TARGETS.get("news_uid")
if not uid:
return
self.client.post(f"/admin/news/{uid}/delete", name="admin/news/delete")
@task(1)
def user_role(self):
uid = ADMIN_TARGETS.get("disposable_uid")
if not uid:
return
self.client.post(
f"/admin/users/{uid}/role", data={"role": "Member"},
name="admin/users/role",
)
@task(1)
def user_password(self):
uid = ADMIN_TARGETS.get("disposable_uid")
if not uid:
return
self.client.post(
f"/admin/users/{uid}/password", data={"password": PASSWORD},
name="admin/users/password",
)
@task(1)
def user_toggle(self):
uid = ADMIN_TARGETS.get("disposable_uid")
if not uid:
return
self.client.post(
f"/admin/users/{uid}/toggle", name="admin/users/toggle"
)
Reference in New Issue View Git Blame Copy Permalink