forked from retoor/devplacepy
retoor
ca6c527e32
The primary administrator was the earliest Admin by created_at with no further condition, so a soft-deleted or deactivated account could hold the role and then be refused by the api-key path, leaving nobody able to use the database API, the backup download or cross-owner container management. Rows with no recorded signup time also sorted ahead of every real account. Scan the earliest admins instead and take the first that is neither deleted nor deactivated, with missing timestamps sorted last. Also stop the projects listing returning 500 when project_type or description is NULL (the dict default never applies to an existing NULL column), align the issue test fixture with its unit twin so a combined run cannot collide on a fixed uid, read the settings value from the database rather than a stale per-process cache, and give the seeded and fixture admins the is_active and created_at fields that every real signup writes.
299 lines
8.5 KiB
Python
299 lines
8.5 KiB
Python
# retoor <retoor@molodetz.nl>
|
|
|
|
from devplacepy.database import (
|
|
get_table,
|
|
get_primary_admin_uid,
|
|
invalidate_admins_cache,
|
|
)
|
|
from devplacepy.utils import (
|
|
award_badge,
|
|
award_xp,
|
|
get_badge,
|
|
check_milestone_badges,
|
|
create_mention_notifications,
|
|
extract_mentions,
|
|
generate_uid,
|
|
hash_password,
|
|
is_primary_admin,
|
|
level_for_xp,
|
|
safe_next,
|
|
slugify,
|
|
strip_html,
|
|
time_ago,
|
|
verify_password,
|
|
)
|
|
from datetime import datetime, timedelta, timezone
|
|
def _seed_user(role="Member", xp=0, level=1):
|
|
uid = generate_uid()
|
|
username = f"ut_{uid[:8]}"
|
|
get_table("users").insert(
|
|
{
|
|
"uid": uid,
|
|
"username": username,
|
|
"email": f"{username}@t.dev",
|
|
"role": role,
|
|
"xp": xp,
|
|
"level": level,
|
|
"created_at": datetime.now(timezone.utc).isoformat(),
|
|
}
|
|
)
|
|
return uid, username
|
|
|
|
|
|
def test_hash_password_returns_string():
|
|
result = hash_password("test123")
|
|
assert isinstance(result, str)
|
|
assert len(result) > 20
|
|
|
|
|
|
def test_verify_password_correct():
|
|
hashed = hash_password("correct-password")
|
|
assert verify_password("correct-password", hashed) is True
|
|
|
|
|
|
def test_verify_password_wrong():
|
|
hashed = hash_password("correct-password")
|
|
assert verify_password("wrong-password", hashed) is False
|
|
|
|
|
|
def test_generate_uid_is_unique():
|
|
uid1 = generate_uid()
|
|
uid2 = generate_uid()
|
|
assert uid1 != uid2
|
|
|
|
|
|
def test_generate_uid_format():
|
|
uid = generate_uid()
|
|
assert isinstance(uid, str)
|
|
assert len(uid) == 36 # UUID v4 format
|
|
|
|
|
|
def test_slugify_basic():
|
|
assert slugify("Hello World") == "hello-world"
|
|
|
|
|
|
def test_slugify_special_chars():
|
|
assert slugify("Hello! World???") == "hello-world"
|
|
|
|
|
|
def test_slugify_multiple_dashes():
|
|
assert slugify("hello---world") == "hello-world"
|
|
|
|
|
|
def test_slugify_leading_trailing():
|
|
assert slugify("--hello--") == "hello"
|
|
|
|
|
|
def test_time_ago_just_now():
|
|
now = datetime.now(timezone.utc).isoformat()
|
|
result = time_ago(now)
|
|
assert result == "just now"
|
|
|
|
|
|
def test_time_ago_minutes():
|
|
dt = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
|
|
result = time_ago(dt)
|
|
assert "m ago" in result
|
|
|
|
|
|
def test_time_ago_hours():
|
|
dt = (datetime.now(timezone.utc) - timedelta(hours=3)).isoformat()
|
|
result = time_ago(dt)
|
|
assert "h ago" in result
|
|
|
|
|
|
def test_time_ago_days():
|
|
dt = (datetime.now(timezone.utc) - timedelta(days=5)).isoformat()
|
|
result = time_ago(dt)
|
|
assert "d ago" in result
|
|
|
|
|
|
def test_time_ago_months():
|
|
dt = datetime.now(timezone.utc) - timedelta(days=60)
|
|
result = time_ago(dt.isoformat())
|
|
assert result == dt.strftime("%d/%m/%Y")
|
|
|
|
|
|
def test_time_ago_years():
|
|
dt = datetime.now(timezone.utc) - timedelta(days=400)
|
|
result = time_ago(dt.isoformat())
|
|
assert result == dt.strftime("%d/%m/%Y")
|
|
|
|
|
|
def test_level_for_xp_boundaries():
|
|
assert level_for_xp(0) == 1
|
|
assert level_for_xp(99) == 1
|
|
assert level_for_xp(100) == 2
|
|
assert level_for_xp(250) == 3
|
|
assert level_for_xp(450) == 5
|
|
|
|
|
|
def test_level_for_xp_negative():
|
|
assert level_for_xp(-50) == 1
|
|
|
|
|
|
def test_badge_info_known():
|
|
meta = get_badge("Star Author")
|
|
assert meta["icon"]
|
|
assert meta["description"] == "Earned 100 stars"
|
|
|
|
|
|
def test_badge_info_unknown_fallback():
|
|
meta = get_badge("Nonexistent Badge")
|
|
assert meta["icon"]
|
|
assert meta["description"] == "Nonexistent Badge"
|
|
|
|
|
|
def test_safe_next_allows_internal_rejects_external():
|
|
assert safe_next("/gists") == "/gists"
|
|
assert safe_next("//evil.com") == "/feed"
|
|
assert safe_next("http://evil.com") == "/feed"
|
|
assert safe_next(None) == "/feed"
|
|
|
|
|
|
def test_strip_html_removes_tags_and_unescapes():
|
|
assert strip_html("<b>Hi</b> & bye") == "Hi & bye"
|
|
assert strip_html("") == ""
|
|
|
|
|
|
def test_extract_mentions_finds_usernames():
|
|
mentions = extract_mentions("hi @alice and (@bob_1), mail a@b.com")
|
|
assert mentions == ["alice", "bob_1"]
|
|
|
|
|
|
def _seed_user_at(role, created_at):
|
|
uid = generate_uid()
|
|
get_table("users").insert(
|
|
{
|
|
"uid": uid,
|
|
"username": f"pa_{uid[:8]}",
|
|
"email": f"pa_{uid[:8]}@t.dev",
|
|
"role": role,
|
|
"created_at": created_at.isoformat(),
|
|
# every real account is created active; the primary administrator must be
|
|
# an account that can actually authenticate
|
|
"is_active": True,
|
|
"deleted_at": None,
|
|
}
|
|
)
|
|
invalidate_admins_cache()
|
|
return get_table("users").find_one(uid=uid)
|
|
|
|
|
|
def _demote_existing_admins():
|
|
existing = [r["uid"] for r in get_table("users").find(role="Admin")]
|
|
for uid in existing:
|
|
get_table("users").update({"uid": uid, "role": "Member"}, ["uid"])
|
|
invalidate_admins_cache()
|
|
return existing
|
|
|
|
|
|
def _restore_admins(uids):
|
|
for uid in uids:
|
|
get_table("users").update({"uid": uid, "role": "Admin"}, ["uid"])
|
|
invalidate_admins_cache()
|
|
|
|
|
|
def _purge(*rows):
|
|
for row in rows:
|
|
get_table("users").delete(uid=row["uid"])
|
|
|
|
|
|
def test_primary_admin_is_earliest_admin(local_db):
|
|
restore = _demote_existing_admins()
|
|
member = admin_first = admin_second = None
|
|
try:
|
|
base = datetime.now(timezone.utc)
|
|
member = _seed_user_at("Member", base)
|
|
admin_first = _seed_user_at("Admin", base + timedelta(seconds=1))
|
|
admin_second = _seed_user_at("Admin", base + timedelta(seconds=2))
|
|
|
|
assert get_primary_admin_uid() == admin_first["uid"]
|
|
assert is_primary_admin(admin_first) is True
|
|
assert is_primary_admin(admin_second) is False
|
|
assert is_primary_admin(member) is False
|
|
assert is_primary_admin(None) is False
|
|
finally:
|
|
_purge(*[r for r in (member, admin_first, admin_second) if r])
|
|
_restore_admins(restore)
|
|
|
|
|
|
def test_primary_admin_reassigns_when_founder_demoted(local_db):
|
|
restore = _demote_existing_admins()
|
|
admin_first = admin_second = None
|
|
try:
|
|
base = datetime.now(timezone.utc)
|
|
admin_first = _seed_user_at("Admin", base + timedelta(seconds=1))
|
|
admin_second = _seed_user_at("Admin", base + timedelta(seconds=2))
|
|
assert get_primary_admin_uid() == admin_first["uid"]
|
|
|
|
get_table("users").update(
|
|
{"uid": admin_first["uid"], "role": "Member"}, ["uid"]
|
|
)
|
|
invalidate_admins_cache()
|
|
assert get_primary_admin_uid() == admin_second["uid"]
|
|
assert (
|
|
is_primary_admin(get_table("users").find_one(uid=admin_second["uid"]))
|
|
is True
|
|
)
|
|
assert (
|
|
is_primary_admin(get_table("users").find_one(uid=admin_first["uid"]))
|
|
is False
|
|
)
|
|
finally:
|
|
_purge(*[r for r in (admin_first, admin_second) if r])
|
|
_restore_admins(restore)
|
|
|
|
|
|
def test_award_badge_is_idempotent(local_db):
|
|
uid, _ = _seed_user()
|
|
assert award_badge(uid, "First Post") is True
|
|
assert award_badge(uid, "First Post") is False
|
|
|
|
|
|
def test_award_xp_levels_up_and_notifies(local_db):
|
|
uid, _ = _seed_user(xp=95, level=1)
|
|
result = award_xp(uid, 10)
|
|
assert result["xp"] == 105
|
|
assert result["level"] == 2
|
|
assert result["leveled_up"] is True
|
|
assert get_table("notifications").count(user_uid=uid, type="level") == 1
|
|
|
|
|
|
def test_check_milestone_badges_awards_prolific(local_db):
|
|
uid, _ = _seed_user()
|
|
posts = get_table("posts")
|
|
for index in range(10):
|
|
post_uid = generate_uid()
|
|
posts.insert(
|
|
{
|
|
"deleted_at": None,
|
|
"deleted_by": None,
|
|
"uid": post_uid,
|
|
"user_uid": uid,
|
|
"slug": f"{post_uid[:8]}-p",
|
|
"title": None,
|
|
"content": f"milestone post {index}",
|
|
"topic": "random",
|
|
"project_uid": None,
|
|
"image": None,
|
|
"stars": 0,
|
|
"created_at": datetime.now(timezone.utc).isoformat(),
|
|
}
|
|
)
|
|
awarded = check_milestone_badges(uid)
|
|
assert "Prolific" in awarded
|
|
assert get_table("badges").find_one(user_uid=uid, badge_name="Prolific") is not None
|
|
|
|
|
|
def test_create_mention_notifications_targets_known_users(local_db):
|
|
actor_uid, actor_name = _seed_user()
|
|
target_uid, target_name = _seed_user()
|
|
create_mention_notifications(
|
|
f"hey @{target_name} and @{actor_name} and @ghost_zzz",
|
|
actor_uid,
|
|
"/posts/x",
|
|
)
|
|
assert get_table("notifications").count(user_uid=target_uid, type="mention") == 1
|
|
assert get_table("notifications").count(user_uid=actor_uid, type="mention") == 0
|